mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #123194 - matthiaskrgr:rollup-vhdc8hw, r=matthiaskrgr

Browse Source 
Rollup of 4 pull requests

Successful merges:

 - #123176 (Normalize the result of `Fields::ty_with_args`)
 - #123186 (copy any file from stage0/lib to stage0-sysroot/lib)
 - #123187 (Forward port 1.77.1 release notes)
 - #123188 (compiler: fix few unused_peekable and needless_pass_by_ref_mut clippy lints)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-03-29 16:02:04 +00:00
commit 399fa2f6e4
45 changed files with 224 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
RELEASES.md
View File

@ -1,3 +1,13 @@
Version 1.77.1 (2024-03-28)
===========================
<a id="1.77.1"></a>
- [Revert stripping debuginfo by default for Windows](https://github.com/rust-lang/cargo/pull/13654)
This fixes a regression in 1.77 by reverting to the previous default.
Platforms other than Windows are not affected.
- Internal: [Fix heading anchor rendering in doc pages](https://github.com/rust-lang/rust/pull/122693)
Version 1.77.0 (2024-03-21)
==========================

2
compiler/rustc_ast_passes/src/ast_validation.rs
View File

@ -1552,7 +1552,7 @@ fn visit_assoc_item(&mut self, item: &'a AssocItem, ctxt: AssocCtxt) {
/// When encountering an equality constraint in a `where` clause, emit an error. If the code seems
/// like it's setting an associated type, provide an appropriate suggestion.
fn deny_equality_constraints(
this: &mut AstValidator<'_>,
this: &AstValidator<'_>,
predicate: &WhereEqPredicate,
generics: &Generics,
) {

20
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View File

@ -337,7 +337,7 @@ pub(crate) fn report_use_of_moved_or_uninitialized(
}
fn suggest_ref_or_clone(
&mut self,
&self,
mpi: MovePathIndex,
move_span: Span,
err: &mut Diag<'tcx>,
@ -1125,7 +1125,7 @@ pub(crate) fn report_move_out_while_borrowed(
}
pub(crate) fn report_use_while_mutably_borrowed(
&mut self,
&self,
location: Location,
(place, _span): (Place<'tcx>, Span),
borrow: &BorrowData<'tcx>,
@ -1174,7 +1174,7 @@ pub(crate) fn report_use_while_mutably_borrowed(
}
pub(crate) fn report_conflicting_borrow(
&mut self,
&self,
location: Location,
(place, span): (Place<'tcx>, Span),
gen_borrow_kind: BorrowKind,
@ -2463,7 +2463,7 @@ pub(crate) fn report_borrowed_value_does_not_live_long_enough(
}
fn report_local_value_does_not_live_long_enough(
&mut self,
&self,
location: Location,
name: &str,
borrow: &BorrowData<'tcx>,
@ -2642,7 +2642,7 @@ fn report_borrow_conflicts_with_destructor(
}
fn report_thread_local_value_does_not_live_long_enough(
&mut self,
&self,
drop_span: Span,
borrow_span: Span,
) -> Diag<'tcx> {
@ -2663,7 +2663,7 @@ fn report_thread_local_value_does_not_live_long_enough(
#[instrument(level = "debug", skip(self))]
fn report_temporary_value_does_not_live_long_enough(
&mut self,
&self,
location: Location,
borrow: &BorrowData<'tcx>,
drop_span: Span,
@ -2921,7 +2921,7 @@ fn try_report_cannot_return_reference_to_local(
#[instrument(level = "debug", skip(self))]
fn report_escaping_closure_capture(
&mut self,
&self,
use_span: UseSpans<'tcx>,
var_span: Span,
fr_name: &RegionName,
@ -3031,7 +3031,7 @@ fn report_escaping_closure_capture(
}
fn report_escaping_data(
&mut self,
&self,
borrow_span: Span,
name: &Option<String>,
upvar_span: Span,
@ -3065,7 +3065,7 @@ fn report_escaping_data(
}
fn get_moved_indexes(
&mut self,
&self,
location: Location,
mpi: MovePathIndex,
) -> (Vec<MoveSite>, Vec<Location>) {
@ -3854,7 +3854,7 @@ enum AnnotatedBorrowFnSignature<'tcx> {
impl<'tcx> AnnotatedBorrowFnSignature<'tcx> {
/// Annotate the provided diagnostic with information about borrow from the fn signature that
/// helps explain.
pub(crate) fn emit(&self, cx: &mut MirBorrowckCtxt<'_, 'tcx>, diag: &mut Diag<'_>) -> String {
pub(crate) fn emit(&self, cx: &MirBorrowckCtxt<'_, 'tcx>, diag: &mut Diag<'_>) -> String {
match self {
&AnnotatedBorrowFnSignature::Closure { argument_ty, argument_span } => {
diag.span_label(

2
compiler/rustc_borrowck/src/type_check/liveness/polonius.rs
View File

@ -87,6 +87,8 @@ pub(super) fn populate_access_facts<'a, 'tcx>(
body: &Body<'tcx>,
location_table: &LocationTable,
move_data: &MoveData<'tcx>,
//FIXME: this is not mutated, but expected to be modified as
// out param, bug?
dropped_at: &mut Vec<(Local, Location)>,
) {
debug!("populate_access_facts()");

9
compiler/rustc_borrowck/src/type_check/liveness/trace.rs
View File

@ -200,7 +200,7 @@ fn dropck_boring_locals(&mut self, boring_locals: Vec<Local>) {
for local in boring_locals {
let local_ty = self.cx.body.local_decls[local].ty;
let drop_data = self.cx.drop_data.entry(local_ty).or_insert_with({
let typeck = &mut self.cx.typeck;
let typeck = &self.cx.typeck;
move || LivenessContext::compute_drop_data(typeck, local_ty)
});
@ -542,7 +542,7 @@ fn add_drop_live_facts_for(
);
let drop_data = self.drop_data.entry(dropped_ty).or_insert_with({
let typeck = &mut self.typeck;
let typeck = &self.typeck;
move || Self::compute_drop_data(typeck, dropped_ty)
});
@ -597,10 +597,7 @@ fn make_all_regions_live(
});
}
fn compute_drop_data(
typeck: &mut TypeChecker<'_, 'tcx>,
dropped_ty: Ty<'tcx>,
) -> DropData<'tcx> {
fn compute_drop_data(typeck: &TypeChecker<'_, 'tcx>, dropped_ty: Ty<'tcx>) -> DropData<'tcx> {
debug!("compute_drop_data(dropped_ty={:?})", dropped_ty,);
match typeck

6
compiler/rustc_builtin_macros/src/asm.rs
View File

@ -29,7 +29,7 @@ pub struct AsmArgs {
}
fn parse_args<'a>(
ecx: &mut ExtCtxt<'a>,
ecx: &ExtCtxt<'a>,
sp: Span,
tts: TokenStream,
is_global_asm: bool,
@ -303,7 +303,7 @@ pub fn parse_asm_args<'a>(
///
/// This function must be called immediately after the option token is parsed.
/// Otherwise, the suggestion will be incorrect.
fn err_duplicate_option(p: &mut Parser<'_>, symbol: Symbol, span: Span) {
fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
// Tool-only output
let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span };
p.psess.dcx.emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span });
@ -315,7 +315,7 @@ fn err_duplicate_option(p: &mut Parser<'_>, symbol: Symbol, span: Span) {
/// This function must be called immediately after the option token is parsed.
/// Otherwise, the error will not point to the correct spot.
fn try_set_option<'a>(
p: &mut Parser<'a>,
p: &Parser<'a>,
args: &mut AsmArgs,
symbol: Symbol,
option: ast::InlineAsmOptions,

2
compiler/rustc_builtin_macros/src/assert.rs
View File

@ -111,7 +111,7 @@ fn expr_if_not(
cx.expr_if(span, cx.expr(span, ExprKind::Unary(UnOp::Not, cond)), then, els)
}
fn parse_assert<'a>(cx: &mut ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<'a, Assert> {
fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<'a, Assert> {
let mut parser = cx.new_parser_from_tts(stream);
if parser.token == token::Eof {

2
compiler/rustc_builtin_macros/src/cfg.rs
View File

@ -35,7 +35,7 @@ pub fn expand_cfg(
})
}
fn parse_cfg<'a>(cx: &mut ExtCtxt<'a>, span: Span, tts: TokenStream) -> PResult<'a, ast::MetaItem> {
fn parse_cfg<'a>(cx: &ExtCtxt<'a>, span: Span, tts: TokenStream) -> PResult<'a, ast::MetaItem> {
let mut p = cx.new_parser_from_tts(tts);
if p.token == token::Eof {

2
compiler/rustc_builtin_macros/src/cfg_accessible.rs
View File

@ -10,7 +10,7 @@
pub(crate) struct Expander;
fn validate_input<'a>(ecx: &mut ExtCtxt<'_>, mi: &'a ast::MetaItem) -> Option<&'a ast::Path> {
fn validate_input<'a>(ecx: &ExtCtxt<'_>, mi: &'a ast::MetaItem) -> Option<&'a ast::Path> {
use errors::CfgAccessibleInvalid::*;
match mi.meta_item_list() {
None => {}

4
compiler/rustc_builtin_macros/src/concat_bytes.rs
View File

@ -8,7 +8,7 @@
/// Emits errors for literal expressions that are invalid inside and outside of an array.
fn invalid_type_err(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
token_lit: token::Lit,
span: Span,
is_nested: bool,
@ -65,7 +65,7 @@ fn invalid_type_err(
/// Otherwise, returns `None`, and either pushes the `expr`'s span to `missing_literals` or
/// updates `guar` accordingly.
fn handle_array_element(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
guar: &mut Option<ErrorGuaranteed>,
missing_literals: &mut Vec<rustc_span::Span>,
expr: &P<rustc_ast::Expr>,

4
compiler/rustc_builtin_macros/src/deriving/bounds.rs
View File

@ -6,7 +6,7 @@
use rustc_span::Span;
pub fn expand_deriving_copy(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -29,7 +29,7 @@ pub fn expand_deriving_copy(
}
pub fn expand_deriving_const_param_ty(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,

8
compiler/rustc_builtin_macros/src/deriving/clone.rs
View File

@ -9,7 +9,7 @@
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_clone(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -94,7 +94,7 @@ pub fn expand_deriving_clone(
fn cs_clone_simple(
name: &str,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
is_union: bool,
@ -157,14 +157,14 @@ fn cs_clone_simple(
fn cs_clone(
name: &str,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
) -> BlockOrExpr {
let ctor_path;
let all_fields;
let fn_path = cx.std_path(&[sym::clone, sym::Clone, sym::clone]);
let subcall = |cx: &mut ExtCtxt<'_>, field: &FieldInfo| {
let subcall = |cx: &ExtCtxt<'_>, field: &FieldInfo| {
let args = thin_vec![field.self_expr.clone()];
cx.expr_call_global(field.span, fn_path.clone(), args)
};

4
compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
View File

@ -10,7 +10,7 @@
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_eq(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -49,7 +49,7 @@ pub fn expand_deriving_eq(
}
fn cs_total_eq_assert(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
) -> BlockOrExpr {

4
compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
View File

@ -8,7 +8,7 @@
use thin_vec::thin_vec;
pub fn expand_deriving_ord(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -39,7 +39,7 @@ pub fn expand_deriving_ord(
trait_def.expand(cx, mitem, item, push)
}
pub fn cs_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
pub fn cs_cmp(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
let test_id = Ident::new(sym::cmp, span);
let equal_path = cx.path_global(span, cx.std_path(&[sym::cmp, sym::Ordering, sym::Equal]));
let cmp_path = cx.std_path(&[sym::cmp, sym::Ord, sym::cmp]);

4
compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
View File

@ -9,14 +9,14 @@
use thin_vec::thin_vec;
pub fn expand_deriving_partial_eq(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
push: &mut dyn FnMut(Annotatable),
is_const: bool,
) {
fn cs_eq(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
fn cs_eq(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
let base = true;
let expr = cs_fold(
true, // use foldl

4
compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
View File

@ -8,7 +8,7 @@
use thin_vec::thin_vec;
pub fn expand_deriving_partial_ord(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -69,7 +69,7 @@ pub fn expand_deriving_partial_ord(
}
fn cs_partial_cmp(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
substr: &Substructure<'_>,
tag_then_data: bool,

6
compiler/rustc_builtin_macros/src/deriving/debug.rs
View File

@ -9,7 +9,7 @@
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_debug(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -45,7 +45,7 @@ pub fn expand_deriving_debug(
trait_def.expand(cx, mitem, item, push)
}
fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
fn show_substructure(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
// We want to make sure we have the ctxt set so that we can use unstable methods
let span = cx.with_def_site_ctxt(span);
@ -209,7 +209,7 @@ fn expr_for_field(
/// }
/// ```
fn show_fieldless_enum(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
def: &EnumDef,
substr: &Substructure<'_>,

8
compiler/rustc_builtin_macros/src/deriving/decodable.rs
View File

@ -11,7 +11,7 @@
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_rustc_decodable(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -63,7 +63,7 @@ pub fn expand_deriving_rustc_decodable(
}
fn decodable_substructure(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
krate: Symbol,
@ -186,14 +186,14 @@ fn decodable_substructure(
/// - `outer_pat_path` is the path to this enum variant/struct
/// - `getarg` should retrieve the `usize`-th field with name `@str`.
fn decode_static_fields<F>(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
outer_pat_path: ast::Path,
fields: &StaticFields,
mut getarg: F,
) -> P<Expr>
where
F: FnMut(&mut ExtCtxt<'_>, Span, Symbol, usize) -> P<Expr>,
F: FnMut(&ExtCtxt<'_>, Span, Symbol, usize) -> P<Expr>,
{
match fields {
Unnamed(fields, is_tuple) => {

10
compiler/rustc_builtin_macros/src/deriving/default.rs
View File

@ -13,7 +13,7 @@
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_default(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &ast::MetaItem,
item: &Annotatable,
@ -54,7 +54,7 @@ pub fn expand_deriving_default(
}
fn default_struct_substructure(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
summary: &StaticFields,
@ -81,7 +81,7 @@ fn default_struct_substructure(
}
fn default_enum_substructure(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
enum_def: &EnumDef,
) -> BlockOrExpr {
@ -103,7 +103,7 @@ fn default_enum_substructure(
}
fn extract_default_variant<'a>(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
enum_def: &'a EnumDef,
trait_span: Span,
) -> Result<&'a rustc_ast::Variant, ErrorGuaranteed> {
@ -173,7 +173,7 @@ fn extract_default_variant<'a>(
}
fn validate_default_attribute(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
default_variant: &rustc_ast::Variant,
) -> Result<(), ErrorGuaranteed> {
let attrs: SmallVec<[_; 1]> =

4
compiler/rustc_builtin_macros/src/deriving/encodable.rs
View File

@ -95,7 +95,7 @@
use thin_vec::{thin_vec, ThinVec};
pub fn expand_deriving_rustc_encodable(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -147,7 +147,7 @@ pub fn expand_deriving_rustc_encodable(
}
fn encodable_substructure(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
krate: Symbol,

40
compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
View File

@ -330,7 +330,7 @@ pub enum SubstructureFields<'a> {
/// Combine the values of all the fields together. The last argument is
/// all the fields of all the structures.
pub type CombineSubstructureFunc<'a> =
Box<dyn FnMut(&mut ExtCtxt<'_>, Span, &Substructure<'_>) -> BlockOrExpr + 'a>;
Box<dyn FnMut(&ExtCtxt<'_>, Span, &Substructure<'_>) -> BlockOrExpr + 'a>;
pub fn combine_substructure(
f: CombineSubstructureFunc<'_>,
@ -454,7 +454,7 @@ fn visit_mac_call(&mut self, mac: &ast::MacCall) {
impl<'a> TraitDef<'a> {
pub fn expand(
self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
mitem: &ast::MetaItem,
item: &'a Annotatable,
push: &mut dyn FnMut(Annotatable),
@ -464,7 +464,7 @@ pub fn expand(
pub fn expand_ext(
self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
mitem: &ast::MetaItem,
item: &'a Annotatable,
push: &mut dyn FnMut(Annotatable),
@ -577,7 +577,7 @@ pub fn expand_ext(
/// therefore does not get bound by the derived trait.
fn create_derived_impl(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
type_ident: Ident,
generics: &Generics,
field_tys: Vec<P<ast::Ty>>,
@ -802,7 +802,7 @@ fn create_derived_impl(
fn expand_struct_def(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
struct_def: &'a VariantData,
type_ident: Ident,
generics: &Generics,
@ -856,7 +856,7 @@ fn expand_struct_def(
fn expand_enum_def(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
enum_def: &'a EnumDef,
type_ident: Ident,
generics: &Generics,
@ -914,7 +914,7 @@ fn expand_enum_def(
impl<'a> MethodDef<'a> {
fn call_substructure_method(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'_>,
type_ident: Ident,
nonselflike_args: &[P<Expr>],
@ -929,7 +929,7 @@ fn call_substructure_method(
fn get_ret_ty(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'_>,
generics: &Generics,
type_ident: Ident,
@ -950,7 +950,7 @@ fn is_static(&self) -> bool {
// `&self`.
fn extract_arg_details(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'_>,
type_ident: Ident,
generics: &Generics,
@ -986,7 +986,7 @@ fn extract_arg_details(
fn create_method(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'_>,
type_ident: Ident,
generics: &Generics,
@ -1077,7 +1077,7 @@ fn create_method(
/// ```
fn expand_struct_method_body<'b>(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'b>,
struct_def: &'b VariantData,
type_ident: Ident,
@ -1100,7 +1100,7 @@ fn expand_struct_method_body<'b>(
fn expand_static_struct_method_body(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'_>,
struct_def: &VariantData,
type_ident: Ident,
@ -1154,7 +1154,7 @@ fn expand_static_struct_method_body(
/// `Unify`), and possibly a default arm.
fn expand_enum_method_body<'b>(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'b>,
enum_def: &'b EnumDef,
type_ident: Ident,
@ -1403,7 +1403,7 @@ fn expand_enum_method_body<'b>(
fn expand_static_enum_method_body(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_: &TraitDef<'_>,
enum_def: &EnumDef,
type_ident: Ident,
@ -1430,7 +1430,7 @@ fn expand_static_enum_method_body(
// general helper methods.
impl<'a> TraitDef<'a> {
fn summarise_struct(&self, cx: &mut ExtCtxt<'_>, struct_def: &VariantData) -> StaticFields {
fn summarise_struct(&self, cx: &ExtCtxt<'_>, struct_def: &VariantData) -> StaticFields {
let mut named_idents = Vec::new();
let mut just_spans = Vec::new();
for field in struct_def.fields() {
@ -1460,7 +1460,7 @@ fn summarise_struct(&self, cx: &mut ExtCtxt<'_>, struct_def: &VariantData) -> St
fn create_struct_patterns(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
struct_path: ast::Path,
struct_def: &'a VariantData,
prefixes: &[String],
@ -1553,7 +1553,7 @@ fn mk_pattern_ident(&self, prefix: &str, i: usize) -> Ident {
fn create_struct_pattern_fields(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
struct_def: &'a VariantData,
prefixes: &[String],
) -> Vec<FieldInfo> {
@ -1570,7 +1570,7 @@ fn create_struct_pattern_fields(
fn create_struct_field_access_fields(
&self,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
selflike_args: &[P<Expr>],
struct_def: &'a VariantData,
is_packed: bool,
@ -1668,13 +1668,13 @@ pub enum CsFold<'a> {
/// Statics may not be folded over.
pub fn cs_fold<F>(
use_foldl: bool,
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
trait_span: Span,
substructure: &Substructure<'_>,
mut f: F,
) -> P<Expr>
where
F: FnMut(&mut ExtCtxt<'_>, CsFold<'_>) -> P<Expr>,
F: FnMut(&ExtCtxt<'_>, CsFold<'_>) -> P<Expr>,
{
match substructure.fields {
EnumMatching(.., all_fields) | Struct(_, all_fields) => {

8
compiler/rustc_builtin_macros/src/deriving/hash.rs
View File

@ -8,7 +8,7 @@
use thin_vec::thin_vec;
pub fn expand_deriving_hash(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
span: Span,
mitem: &MetaItem,
item: &Annotatable,
@ -46,11 +46,7 @@ pub fn expand_deriving_hash(
hash_trait_def.expand(cx, mitem, item, push);
}
fn hash_substructure(
cx: &mut ExtCtxt<'_>,
trait_span: Span,
substr: &Substructure<'_>,
) -> BlockOrExpr {
fn hash_substructure(cx: &ExtCtxt<'_>, trait_span: Span, substr: &Substructure<'_>) -> BlockOrExpr {
let [state_expr] = substr.nonselflike_args else {
cx.dcx().span_bug(trait_span, "incorrect number of arguments in `derive(Hash)`");
};

4
compiler/rustc_builtin_macros/src/deriving/mod.rs
View File

@ -40,7 +40,7 @@
pub mod generic;
pub(crate) type BuiltinDeriveFn =
fn(&mut ExtCtxt<'_>, Span, &MetaItem, &Annotatable, &mut dyn FnMut(Annotatable), bool);
fn(&ExtCtxt<'_>, Span, &MetaItem, &Annotatable, &mut dyn FnMut(Annotatable), bool);
pub(crate) struct BuiltinDerive(pub(crate) BuiltinDeriveFn);
@ -117,7 +117,7 @@ fn call_unreachable(cx: &ExtCtxt<'_>, span: Span) -> P<ast::Expr> {
}
fn assert_ty_bounds(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
stmts: &mut ThinVec<ast::Stmt>,
ty: P<ast::Ty>,
span: Span,

2
compiler/rustc_builtin_macros/src/edition_panic.rs
View File

@ -40,7 +40,7 @@ pub fn expand_unreachable<'cx>(
fn expand<'cx>(
mac: rustc_span::Symbol,
cx: &'cx mut ExtCtxt<'_>,
cx: &'cx ExtCtxt<'_>,
sp: Span,
tts: TokenStream,
) -> MacroExpanderResult<'cx> {

8
compiler/rustc_builtin_macros/src/format.rs
View File

@ -65,7 +65,7 @@ struct MacroInput {
/// ```text
/// Ok((fmtstr, parsed arguments))
/// ```
fn parse_args<'a>(ecx: &mut ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a, MacroInput> {
fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a, MacroInput> {
let mut args = FormatArguments::new();
let mut p = ecx.new_parser_from_tts(tts);
@ -604,7 +604,7 @@ fn invalid_placeholder_type_error(
}
fn report_missing_placeholders(
ecx: &mut ExtCtxt<'_>,
ecx: &ExtCtxt<'_>,
unused: Vec<(Span, bool)>,
used: &[bool],
args: &FormatArguments,
@ -734,7 +734,7 @@ macro_rules! check_foreign {
/// This function detects and reports unused format!() arguments that are
/// redundant due to implicit captures (e.g. `format!("{x}", x)`).
fn report_redundant_format_arguments<'a>(
ecx: &mut ExtCtxt<'a>,
ecx: &ExtCtxt<'a>,
args: &FormatArguments,
used: &[bool],
placeholders: Vec<(Span, &str)>,
@ -806,7 +806,7 @@ fn report_redundant_format_arguments<'a>(
/// there are named arguments or numbered positional arguments in the
/// format string.
fn report_invalid_references(
ecx: &mut ExtCtxt<'_>,
ecx: &ExtCtxt<'_>,
invalid_refs: &[(usize, Option<Span>, PositionUsedAs, FormatArgPositionKind)],
template: &[FormatArgsPiece],
fmt_span: Span,

2
compiler/rustc_builtin_macros/src/source_util.rs
View File

@ -234,7 +234,7 @@ pub fn expand_include_bytes(
}
fn load_binary_file(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
original_path: &Path,
macro_span: Span,
path_span: Span,

2
compiler/rustc_builtin_macros/src/test.rs
View File

@ -96,7 +96,7 @@ pub fn expand_bench(
}
pub fn expand_test_or_bench(
cx: &mut ExtCtxt<'_>,
cx: &ExtCtxt<'_>,
attr_sp: Span,
item: Annotatable,
is_bench: bool,

4
compiler/rustc_codegen_ssa/src/back/link.rs
View File

@ -2089,14 +2089,14 @@ fn add_rpath_args(
.map(|(path, _)| &**path)
})
.collect::<Vec<_>>();
let mut rpath_config = RPathConfig {
let rpath_config = RPathConfig {
libs: &*libs,
out_filename: out_filename.to_path_buf(),
has_rpath: sess.target.has_rpath,
is_like_osx: sess.target.is_like_osx,
linker_is_gnu: sess.target.linker_flavor.is_gnu(),
};
cmd.args(&rpath::get_rpath_flags(&mut rpath_config));
cmd.args(&rpath::get_rpath_flags(&rpath_config));
}
}

8
compiler/rustc_codegen_ssa/src/back/rpath.rs
View File

@ -12,7 +12,7 @@ pub struct RPathConfig<'a> {
pub linker_is_gnu: bool,
}
pub fn get_rpath_flags(config: &mut RPathConfig<'_>) -> Vec<OsString> {
pub fn get_rpath_flags(config: &RPathConfig<'_>) -> Vec<OsString> {
// No rpath on windows
if !config.has_rpath {
return Vec::new();
@ -52,7 +52,7 @@ fn rpaths_to_flags(rpaths: Vec<OsString>) -> Vec<OsString> {
ret
}
fn get_rpaths(config: &mut RPathConfig<'_>) -> Vec<OsString> {
fn get_rpaths(config: &RPathConfig<'_>) -> Vec<OsString> {
debug!("output: {:?}", config.out_filename.display());
debug!("libs:");
for libpath in config.libs {
@ -73,11 +73,11 @@ fn get_rpaths(config: &mut RPathConfig<'_>) -> Vec<OsString> {
minimize_rpaths(&rpaths)
}
fn get_rpaths_relative_to_output(config: &mut RPathConfig<'_>) -> Vec<OsString> {
fn get_rpaths_relative_to_output(config: &RPathConfig<'_>) -> Vec<OsString> {
config.libs.iter().map(|a| get_rpath_relative_to_output(config, a)).collect()
}
fn get_rpath_relative_to_output(config: &mut RPathConfig<'_>, lib: &Path) -> OsString {
fn get_rpath_relative_to_output(config: &RPathConfig<'_>, lib: &Path) -> OsString {
// Mac doesn't appear to support $ORIGIN
let prefix = if config.is_like_osx { "@loader_path" } else { "$ORIGIN" };

4
compiler/rustc_expand/src/expand.rs
View File

@ -871,7 +871,7 @@ fn parse_ast_fragment(
let mut parser = self.cx.new_parser_from_tts(toks);
match parse_ast_fragment(&mut parser, kind) {
Ok(fragment) => {
ensure_complete_parse(&mut parser, path, kind.name(), span);
ensure_complete_parse(&parser, path, kind.name(), span);
fragment
}
Err(mut err) => {
@ -958,7 +958,7 @@ pub fn parse_ast_fragment<'a>(
}
pub fn ensure_complete_parse<'a>(
parser: &mut Parser<'a>,
parser: &Parser<'a>,
macro_path: &ast::Path,
kind_name: &str,
span: Span,

6
compiler/rustc_infer/src/infer/snapshot/fudge.rs
View File

@ -13,7 +13,7 @@
use std::ops::Range;
fn vars_since_snapshot<'tcx, T>(
table: &mut UnificationTable<'_, 'tcx, T>,
table: &UnificationTable<'_, 'tcx, T>,
snapshot_var_len: usize,
) -> Range<T>
where
@ -124,11 +124,11 @@ pub fn fudge_inference_if_ok<T, E, F>(&self, f: F) -> Result<T, E>
let type_vars =
inner.type_variables().vars_since_snapshot(variable_lengths.type_var_len);
let int_vars = vars_since_snapshot(
&mut inner.int_unification_table(),
&inner.int_unification_table(),
variable_lengths.int_var_len,
);
let float_vars = vars_since_snapshot(
&mut inner.float_unification_table(),
&inner.float_unification_table(),
variable_lengths.float_var_len,
);
let region_vars = inner

5
compiler/rustc_mir_build/src/build/matches/mod.rs
View File

@ -1593,10 +1593,7 @@ fn merge_trivial_subcandidates(&mut self, candidate: &mut Candidate<'_, 'tcx>) {
/// [`Switch`]: TestKind::Switch
/// [`SwitchInt`]: TestKind::SwitchInt
/// [`Range`]: TestKind::Range
fn pick_test(
&mut self,
candidates: &mut [&mut Candidate<'_, 'tcx>],
) -> (Place<'tcx>, Test<'tcx>) {
fn pick_test(&mut self, candidates: &[&mut Candidate<'_, 'tcx>]) -> (Place<'tcx>, Test<'tcx>) {
// Extract the match-pair from the highest priority candidate
let match_pair = &candidates.first().unwrap().match_pairs[0];
let test = self.test(match_pair);

2
compiler/rustc_mir_transform/src/coroutine.rs
View File

@ -1226,7 +1226,7 @@ fn create_coroutine_drop_shim<'tcx>(
tcx: TyCtxt<'tcx>,
transform: &TransformVisitor<'tcx>,
coroutine_ty: Ty<'tcx>,
body: &mut Body<'tcx>,
body: &Body<'tcx>,
drop_clean: BasicBlock,
) -> Body<'tcx> {
let mut body = body.clone();

7
compiler/rustc_mir_transform/src/nrvo.rs
View File

@ -84,7 +84,7 @@ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut mir::Body<'tcx>) {
///
/// If the MIR fulfills both these conditions, this function returns the `Local` that is assigned
/// to the return place along all possible paths through the control-flow graph.
fn local_eligible_for_nrvo(body: &mut mir::Body<'_>) -> Option<Local> {
fn local_eligible_for_nrvo(body: &mir::Body<'_>) -> Option<Local> {
if IsReturnPlaceRead::run(body) {
return None;
}
@ -118,10 +118,7 @@ fn local_eligible_for_nrvo(body: &mut mir::Body<'_>) -> Option<Local> {
copied_to_return_place
}
fn find_local_assigned_to_return_place(
start: BasicBlock,
body: &mut mir::Body<'_>,
) -> Option<Local> {
fn find_local_assigned_to_return_place(start: BasicBlock, body: &mir::Body<'_>) -> Option<Local> {
let mut block = start;
let mut seen = BitSet::new_empty(body.basic_blocks.len());

10
compiler/rustc_session/src/config.rs
View File

@ -2000,7 +2000,7 @@ pub fn parse_crate_edition(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches
}
fn check_error_format_stability(
early_dcx: &mut EarlyDiagCtxt,
early_dcx: &EarlyDiagCtxt,
unstable_opts: &UnstableOptions,
error_format: ErrorOutputType,
) {
@ -2098,7 +2098,7 @@ fn should_override_cgus_and_disable_thinlto(
fn collect_print_requests(
early_dcx: &EarlyDiagCtxt,
cg: &mut CodegenOptions,
unstable_opts: &mut UnstableOptions,
unstable_opts: &UnstableOptions,
matches: &getopts::Matches,
) -> Vec<PrintRequest> {
let mut prints = Vec::<PrintRequest>::new();
@ -2564,7 +2564,7 @@ fn parse_remap_path_prefix(
}
fn parse_logical_env(
early_dcx: &mut EarlyDiagCtxt,
early_dcx: &EarlyDiagCtxt,
matches: &getopts::Matches,
) -> FxIndexMap<String, String> {
let mut vars = FxIndexMap::default();
@ -2722,6 +2722,8 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
}
if let Ok(graphviz_font) = std::env::var("RUSTC_GRAPHVIZ_FONT") {
// FIXME: this is only mutation of UnstableOptions here, move into
// UnstableOptions::build?
unstable_opts.graphviz_font = graphviz_font;
}
@ -2771,7 +2773,7 @@ pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::M
));
}
let prints = collect_print_requests(early_dcx, &mut cg, &mut unstable_opts, matches);
let prints = collect_print_requests(early_dcx, &mut cg, &unstable_opts, matches);
let cg = cg;

2
compiler/rustc_session/src/utils.rs
View File

@ -127,7 +127,7 @@ pub fn extra_compiler_flags() -> Option<(Vec<String>, bool)> {
const ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE: &[&str] = &["incremental"];
let mut args = std::env::args_os().map(|arg| arg.to_string_lossy().to_string()).peekable();
let mut args = std::env::args_os().map(|arg| arg.to_string_lossy().to_string());
let mut result = Vec::new();
let mut excluded_cargo_defaults = false;

5
compiler/rustc_smir/src/rustc_smir/context.rs
View File

@ -420,7 +420,10 @@ fn def_ty_with_args(&self, item: stable_mir::DefId, args: &GenericArgs) -> stabl
let tcx = tables.tcx;
let args = args.internal(&mut *tables, tcx);
let def_ty = tables.tcx.type_of(item.internal(&mut *tables, tcx));
def_ty.instantiate(tables.tcx, args).stable(&mut *tables)
tables
.tcx
.instantiate_and_normalize_erasing_regions(args, ty::ParamEnv::reveal_all(), def_ty)
.stable(&mut *tables)
}
fn const_pretty(&self, cnst: &stable_mir::ty::Const) -> String {

2
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -4931,7 +4931,7 @@ fn point_at_assoc_type_restriction<G: EmissionGuarantee>(
let hir::WherePredicate::BoundPredicate(pred) = pred else {
continue;
};
let mut bounds = pred.bounds.iter().peekable();
let mut bounds = pred.bounds.iter();
while let Some(bound) = bounds.next() {
let Some(trait_ref) = bound.trait_ref() else {
continue;

2
compiler/rustc_trait_selection/src/traits/project.rs
View File

@ -508,7 +508,7 @@ pub(super) fn opt_normalize_projection_type<'a, 'b, 'tcx>(
/// because it contains `[type error]`. Yuck! (See issue #29857 for
/// one case where this arose.)
fn normalize_to_error<'a, 'tcx>(
selcx: &mut SelectionContext<'a, 'tcx>,
selcx: &SelectionContext<'a, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
projection_ty: ty::AliasTy<'tcx>,
cause: ObligationCause<'tcx>,

4
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View File

@ -239,10 +239,10 @@ fn fulfill_implication<'tcx>(
let source_trait = ImplSubject::Trait(source_trait_ref);
let selcx = &mut SelectionContext::new(infcx);
let selcx = SelectionContext::new(infcx);
let target_args = infcx.fresh_args_for_item(DUMMY_SP, target_impl);
let (target_trait, obligations) =
util::impl_subject_and_oblig(selcx, param_env, target_impl, target_args, error_cause);
util::impl_subject_and_oblig(&selcx, param_env, target_impl, target_args, error_cause);
// do the impls unify? If not, no specialization.
let Ok(InferOk { obligations: more_obligations, .. }) = infcx

2
compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
View File

@ -198,7 +198,7 @@ fn insert(
}
}
fn iter_children(children: &mut Children) -> impl Iterator<Item = DefId> + '_ {
fn iter_children(children: &Children) -> impl Iterator<Item = DefId> + '_ {
let nonblanket = children.non_blanket_impls.iter().flat_map(|(_, v)| v.iter());
children.blanket_impls.iter().chain(nonblanket).cloned()
}

2
compiler/rustc_trait_selection/src/traits/util.rs
View File

@ -205,7 +205,7 @@ fn next(&mut self) -> Option<DefId> {
/// returning the resulting subject and all obligations that arise.
/// The obligations are closed under normalization.
pub fn impl_subject_and_oblig<'a, 'tcx>(
selcx: &mut SelectionContext<'a, 'tcx>,
selcx: &SelectionContext<'a, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
impl_def_id: DefId,
impl_args: GenericArgsRef<'tcx>,

4
compiler/stable_mir/src/ty.rs
View File

@ -654,7 +654,7 @@ pub fn ty(&self) -> Ty {
with(|cx| cx.def_ty(self.0))
}
/// Retrieve the type of this Adt instantiating the type with the given arguments.
/// Retrieve the type of this Adt by instantiating and normalizing it with the given arguments.
///
/// This will assume the type can be instantiated with these arguments.
pub fn ty_with_args(&self, args: &GenericArgs) -> Ty {
@ -733,7 +733,7 @@ pub struct FieldDef {
}
impl FieldDef {
/// Retrieve the type of this field instantiating the type with the given arguments.
/// Retrieve the type of this field instantiating and normalizing it with the given arguments.
///
/// This will assume the type can be instantiated with these arguments.
pub fn ty_with_args(&self, args: &GenericArgs) -> Ty {

4
src/bootstrap/src/core/build_steps/compile.rs
View File

@ -643,13 +643,13 @@ fn run(self, builder: &Builder<'_>) {
t!(fs::create_dir_all(&sysroot_bin_dir));
builder.cp_link_r(&stage0_bin_dir, &sysroot_bin_dir);
// Copy all *.so files from stage0/lib to stage0-sysroot/lib
// Copy all files from stage0/lib to stage0-sysroot/lib
let stage0_lib_dir = builder.out.join(host).join("stage0/lib");
if let Ok(files) = fs::read_dir(stage0_lib_dir) {
for file in files {
let file = t!(file);
let path = file.path();
if path.is_file() && is_dylib(&file.file_name().into_string().unwrap()) {
if path.is_file() {
builder
.copy_link(&path, &sysroot.join("lib").join(path.file_name().unwrap()));
}

95
tests/ui-fulldeps/stable-mir/check_normalization.rs Normal file
View File

@ -0,0 +1,95 @@
//@ run-pass
//! Test that types are normalized in an instance body.
//@ ignore-stage1
//@ ignore-cross-compile
//@ ignore-remote
//@ ignore-windows-gnu mingw has troubles with linking https://github.com/rust-lang/rust/pull/116837
//@ edition: 2021
#![feature(rustc_private)]
#[macro_use]
extern crate rustc_smir;
extern crate rustc_driver;
extern crate rustc_interface;
extern crate stable_mir;
use mir::mono::Instance;
use ty::{Ty, TyKind, RigidTy};
use rustc_smir::rustc_internal;
use stable_mir::*;
use std::io::Write;
use std::ops::ControlFlow;
const CRATE_NAME: &str = "input";
/// This function uses the Stable MIR APIs to get information about the test crate.
fn test_stable_mir() -> ControlFlow<()> {
let items = stable_mir::all_local_items();
// Get all items and split generic vs monomorphic items.
let instances: Vec<_> =
items.into_iter().filter_map(|item| (!item.requires_monomorphization()).then(|| {
Instance::try_from(item).unwrap()
})).collect();
assert_eq!(instances.len(), 1, "Expected one constant");
for instance in instances {
check_ty(instance.ty());
}
ControlFlow::Continue(())
}
fn check_ty(ty: Ty) {
match ty.kind() {
TyKind::RigidTy(RigidTy::Adt(def, args)) if def.kind().is_struct() => {
// Ensure field type is also normalized
def.variants_iter().next().unwrap().fields().into_iter().for_each(|f| {
check_ty(f.ty_with_args(&args))
});
}
TyKind::RigidTy(RigidTy::Uint(..)) => {}
kind => unreachable!("Unexpected kind: {kind:?}")
}
}
/// This test will generate and analyze a dummy crate using the stable mir.
/// For that, it will first write the dummy crate into a file.
/// Then it will create a `StableMir` using custom arguments and then
/// it will run the compiler.
fn main() {
let path = "normalization_input.rs";
generate_input(&path).unwrap();
let args = vec![
"rustc".to_string(),
"-Cpanic=abort".to_string(),
"--crate-type=lib".to_string(),
"--crate-name".to_string(),
CRATE_NAME.to_string(),
path.to_string(),
];
run!(args, test_stable_mir).unwrap();
}
fn generate_input(path: &str) -> std::io::Result<()> {
let mut file = std::fs::File::create(path)?;
write!(
file,
r#"
pub trait Primitive {{
type Base;
}}
impl Primitive for char {{
type Base = u32;
}}
pub struct Wrapper<T: Primitive>(T::Base);
pub type WrapperChar = Wrapper<char>;
pub const NULL_CHAR: WrapperChar = Wrapper::<char>(0);
"#
)?;
Ok(())
}