Commit 6868c831a1eb45c5150ff623cef5e42a8b8946d0 | rust

compiler/rustc_lint/messages.ftl-2

...	...	@@ -56,8 +56,6 @@ lint_builtin_asm_labels = avoid using named labels in inline assembly
56	56	.help = only local labels of the form `<number>:` should be used in inline asm
57	57	.note = see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
58	58
59		lint_builtin_box_pointers = type uses owned (Box type) pointers: {$ty}
60
61	59	lint_builtin_clashing_extern_diff_name = `{$this}` redeclares `{$orig}` with a different signature
62	60	.previous_decl_label = `{$orig}` previously declared here
63	61	.mismatch_label = this signature doesn't match the previous declaration

compiler/rustc_lint/src/builtin.rs+3-79

...	...	@@ -24,9 +24,9 @@ use crate::fluent_generated as fluent;
24	24	use crate::{
25	25	errors::BuiltinEllipsisInclusiveRangePatterns,
26	26	lints::{
27		BuiltinAnonymousParams, BuiltinBoxPointers, BuiltinConstNoMangle,
28		BuiltinDeprecatedAttrLink, BuiltinDeprecatedAttrLinkSuggestion, BuiltinDeprecatedAttrUsed,
29		BuiltinDerefNullptr, BuiltinEllipsisInclusiveRangePatternsLint, BuiltinExplicitOutlives,
	27	BuiltinAnonymousParams, BuiltinConstNoMangle, BuiltinDeprecatedAttrLink,
	28	BuiltinDeprecatedAttrLinkSuggestion, BuiltinDeprecatedAttrUsed, BuiltinDerefNullptr,
	29	BuiltinEllipsisInclusiveRangePatternsLint, BuiltinExplicitOutlives,
30	30	BuiltinExplicitOutlivesSuggestion, BuiltinFeatureIssueNote, BuiltinIncompleteFeatures,
31	31	BuiltinIncompleteFeaturesHelp, BuiltinInternalFeatures, BuiltinKeywordIdents,
32	32	BuiltinMissingCopyImpl, BuiltinMissingDebugImpl, BuiltinMissingDoc,
...	...	@@ -56,7 +56,6 @@ use rustc_middle::bug;
56	56	use rustc_middle::lint::in_external_macro;
57	57	use rustc_middle::ty::layout::LayoutOf;
58	58	use rustc_middle::ty::print::with_no_trimmed_paths;
59		use rustc_middle::ty::GenericArgKind;
60	59	use rustc_middle::ty::TypeVisitableExt;
61	60	use rustc_middle::ty::Upcast;
62	61	use rustc_middle::ty::{self, Ty, TyCtxt, VariantDef};
...	...	@@ -134,80 +133,6 @@ impl EarlyLintPass for WhileTrue {
134	133	}
135	134	}
136	135
137		declare_lint! {
138		/// The `box_pointers` lints use of the Box type.
139		///
140		/// ### Example
141		///
142		/// ```rust,compile_fail
143		/// #![deny(box_pointers)]
144		/// struct Foo {
145		/// x: Box<i32>,
146		/// }
147		/// ```
148		///
149		/// {{produces}}
150		///
151		/// ### Explanation
152		///
153		/// This lint is mostly historical, and not particularly useful. `Box<T>`
154		/// used to be built into the language, and the only way to do heap
155		/// allocation. Today's Rust can call into other allocators, etc.
156		BOX_POINTERS,
157		Allow,
158		"use of owned (Box type) heap memory"
159		}
160
161		declare_lint_pass!(BoxPointers => [BOX_POINTERS]);
162
163		impl BoxPointers {
164		fn check_heap_type(&self, cx: &LateContext<'_>, span: Span, ty: Ty<'_>) {
165		for leaf in ty.walk() {
166		if let GenericArgKind::Type(leaf_ty) = leaf.unpack()
167		&& leaf_ty.is_box()
168		{
169		cx.emit_span_lint(BOX_POINTERS, span, BuiltinBoxPointers { ty });
170		}
171		}
172		}
173		}
174
175		impl<'tcx> LateLintPass<'tcx> for BoxPointers {
176		fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
177		match it.kind {
178		hir::ItemKind::Fn(..)
179		\| hir::ItemKind::TyAlias(..)
180		\| hir::ItemKind::Enum(..)
181		\| hir::ItemKind::Struct(..)
182		\| hir::ItemKind::Union(..) => self.check_heap_type(
183		cx,
184		it.span,
185		cx.tcx.type_of(it.owner_id).instantiate_identity(),
186		),
187		_ => (),
188		}
189
190		// If it's a struct, we also have to check the fields' types
191		match it.kind {
192		hir::ItemKind::Struct(ref struct_def, _) \| hir::ItemKind::Union(ref struct_def, _) => {
193		for field in struct_def.fields() {
194		self.check_heap_type(
195		cx,
196		field.span,
197		cx.tcx.type_of(field.def_id).instantiate_identity(),
198		);
199		}
200		}
201		_ => (),
202		}
203		}
204
205		fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
206		let ty = cx.typeck_results().node_type(e.hir_id);
207		self.check_heap_type(cx, e.span, ty);
208		}
209		}
210
211	136	declare_lint! {
212	137	/// The `non_shorthand_field_patterns` lint detects using `Struct { x: x }`
213	138	/// instead of `Struct { x }` in a pattern.
...	...	@@ -1640,7 +1565,6 @@ declare_lint_pass!(
1640	1565	/// which are used by other parts of the compiler.
1641	1566	SoftLints => [
1642	1567	WHILE_TRUE,
1643		BOX_POINTERS,
1644	1568	NON_SHORTHAND_FIELD_PATTERNS,
1645	1569	UNSAFE_CODE,
1646	1570	MISSING_DOCS,

compiler/rustc_lint/src/lib.rs+4-1

...	...	@@ -187,7 +187,6 @@ late_lint_methods!(
187	187	ImproperCTypesDefinitions: ImproperCTypesDefinitions,
188	188	InvalidFromUtf8: InvalidFromUtf8,
189	189	VariantSizeDifferences: VariantSizeDifferences,
190		BoxPointers: BoxPointers,
191	190	PathStatements: PathStatements,
192	191	LetUnderscore: LetUnderscore,
193	192	InvalidReferenceCasting: InvalidReferenceCasting,
...	...	@@ -551,6 +550,10 @@ fn register_builtins(store: &mut LintStore) {
551	550	"converted into hard error, see RFC #3535 \
552	551	<https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
553	552	);
	553	store.register_removed(
	554	"box_pointers",
	555	"it does not detect other kinds of allocations, and existed only for historical reasons",
	556	);
554	557	}
555	558
556	559	fn register_internals(store: &mut LintStore) {

compiler/rustc_lint/src/lints.rs-6

...	...	@@ -66,12 +66,6 @@ pub struct BuiltinWhileTrue {
66	66	pub replace: String,
67	67	}
68	68
69		#[derive(LintDiagnostic)]
70		#[diag(lint_builtin_box_pointers)]
71		pub struct BuiltinBoxPointers<'a> {
72		pub ty: Ty<'a>,
73		}
74
75	69	#[derive(LintDiagnostic)]
76	70	#[diag(lint_builtin_non_shorthand_field_patterns)]
77	71	pub struct BuiltinNonShorthandFieldPatterns {

compiler/rustc_mir_build/src/build/block.rs+17-4

...	...	@@ -1,3 +1,4 @@
	1	use crate::build::matches::{DeclareLetBindings, EmitStorageLive, ScheduleDrops};
1	2	use crate::build::ForGuard::OutsideGuard;
2	3	use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
3	4	use rustc_middle::middle::region::Scope;
...	...	@@ -201,7 +202,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
201	202	pattern,
202	203	UserTypeProjections::none(),
203	204	&mut \|this, _, _, node, span, _, _\| {
204		this.storage_live_binding(block, node, span, OutsideGuard, true);
	205	this.storage_live_binding(
	206	block,
	207	node,
	208	span,
	209	OutsideGuard,
	210	ScheduleDrops::Yes,
	211	);
205	212	},
206	213	);
207	214	let else_block_span = this.thir[*else_block].span;
...	...	@@ -213,8 +220,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
213	220	pattern,
214	221	None,
215	222	initializer_span,
216		false,
217		true,
	223	DeclareLetBindings::No,
	224	EmitStorageLive::No,
218	225	)
219	226	});
220	227	matching.and(failure)
...	...	@@ -291,7 +298,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
291	298	pattern,
292	299	UserTypeProjections::none(),
293	300	&mut \|this, _, _, node, span, _, _\| {
294		this.storage_live_binding(block, node, span, OutsideGuard, true);
	301	this.storage_live_binding(
	302	block,
	303	node,
	304	span,
	305	OutsideGuard,
	306	ScheduleDrops::Yes,
	307	);
295	308	this.schedule_drop_for_binding(node, span, OutsideGuard);
296	309	},
297	310	)

compiler/rustc_mir_build/src/build/expr/into.rs+3-2

...	...	@@ -1,6 +1,7 @@
1	1	//! See docs in build/expr/mod.rs
2	2
3	3	use crate::build::expr::category::{Category, RvalueFunc};
	4	use crate::build::matches::DeclareLetBindings;
4	5	use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder, NeedsTemporary};
5	6	use rustc_ast::InlineAsmOptions;
6	7	use rustc_data_structures::fx::FxHashMap;
...	...	@@ -86,7 +87,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
86	87	cond,
87	88	Some(condition_scope), // Temp scope
88	89	source_info,
89		true, // Declare `let` bindings normally
	90	DeclareLetBindings::Yes, // Declare `let` bindings normally
90	91	));
91	92
92	93	// Lower the `then` arm into its block.
...	...	@@ -163,7 +164,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
163	164	source_info,
164	165	// This flag controls how inner `let` expressions are lowered,
165	166	// but either way there shouldn't be any of those in here.
166		true,
	167	DeclareLetBindings::LetNotPermitted,
167	168	)
168	169	});
169	170	let (short_circuit, continuation, constant) = match op {

compiler/rustc_mir_build/src/build/matches/mod.rs+130-46

...	...	@@ -28,6 +28,7 @@ mod simplify;
28	28	mod test;
29	29	mod util;
30	30
	31	use std::assert_matches::assert_matches;
31	32	use std::borrow::Borrow;
32	33	use std::mem;
33	34
...	...	@@ -39,9 +40,50 @@ struct ThenElseArgs {
39	40	/// `self.local_scope()` is used.
40	41	temp_scope_override: Option<region::Scope>,
41	42	variable_source_info: SourceInfo,
	43	/// Determines how bindings should be handled when lowering `let` expressions.
	44	///
42	45	/// Forwarded to [`Builder::lower_let_expr`] when lowering [`ExprKind::Let`].
43		/// When false (for match guards), `let` bindings won't be declared.
44		declare_let_bindings: bool,
	46	declare_let_bindings: DeclareLetBindings,
	47	}
	48
	49	/// Should lowering a `let` expression also declare its bindings?
	50	///
	51	/// Used by [`Builder::lower_let_expr`] when lowering [`ExprKind::Let`].
	52	#[derive(Clone, Copy)]
	53	pub(crate) enum DeclareLetBindings {
	54	/// Yes, declare `let` bindings as normal for `if` conditions.
	55	Yes,
	56	/// No, don't declare `let` bindings, because the caller declares them
	57	/// separately due to special requirements.
	58	///
	59	/// Used for match guards and let-else.
	60	No,
	61	/// Let expressions are not permitted in this context, so it is a bug to
	62	/// try to lower one (e.g inside lazy-boolean-or or boolean-not).
	63	LetNotPermitted,
	64	}
	65
	66	/// Used by [`Builder::bind_matched_candidate_for_arm_body`] to determine
	67	/// whether or not to call [`Builder::storage_live_binding`] to emit
	68	/// [`StatementKind::StorageLive`].
	69	#[derive(Clone, Copy)]
	70	pub(crate) enum EmitStorageLive {
	71	/// Yes, emit `StorageLive` as normal.
	72	Yes,
	73	/// No, don't emit `StorageLive`. The caller has taken responsibility for
	74	/// emitting `StorageLive` as appropriate.
	75	No,
	76	}
	77
	78	/// Used by [`Builder::storage_live_binding`] and [`Builder::bind_matched_candidate_for_arm_body`]
	79	/// to decide whether to schedule drops.
	80	#[derive(Clone, Copy, Debug)]
	81	pub(crate) enum ScheduleDrops {
	82	/// Yes, the relevant functions should also schedule drops as appropriate.
	83	Yes,
	84	/// No, don't schedule drops. The caller has taken responsibility for any
	85	/// appropriate drops.
	86	No,
45	87	}
46	88
47	89	impl<'a, 'tcx> Builder<'a, 'tcx> {
...	...	@@ -57,7 +99,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
57	99	expr_id: ExprId,
58	100	temp_scope_override: Option<region::Scope>,
59	101	variable_source_info: SourceInfo,
60		declare_let_bindings: bool,
	102	declare_let_bindings: DeclareLetBindings,
61	103	) -> BlockAnd<()> {
62	104	self.then_else_break_inner(
63	105	block,
...	...	@@ -91,13 +133,19 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
91	133	this.then_else_break_inner(
92	134	block,
93	135	lhs,
94		ThenElseArgs { declare_let_bindings: true, ..args },
	136	ThenElseArgs {
	137	declare_let_bindings: DeclareLetBindings::LetNotPermitted,
	138	..args
	139	},
95	140	)
96	141	});
97	142	let rhs_success_block = unpack!(this.then_else_break_inner(
98	143	failure_block,
99	144	rhs,
100		ThenElseArgs { declare_let_bindings: true, ..args },
	145	ThenElseArgs {
	146	declare_let_bindings: DeclareLetBindings::LetNotPermitted,
	147	..args
	148	},
101	149	));
102	150
103	151	// Make the LHS and RHS success arms converge to a common block.
...	...	@@ -127,7 +175,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
127	175	this.then_else_break_inner(
128	176	block,
129	177	arg,
130		ThenElseArgs { declare_let_bindings: true, ..args },
	178	ThenElseArgs {
	179	declare_let_bindings: DeclareLetBindings::LetNotPermitted,
	180	..args
	181	},
131	182	)
132	183	});
133	184	this.break_for_else(success_block, args.variable_source_info);
...	...	@@ -147,7 +198,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
147	198	Some(args.variable_source_info.scope),
148	199	args.variable_source_info.span,
149	200	args.declare_let_bindings,
150		false,
	201	EmitStorageLive::Yes,
151	202	),
152	203	_ => {
153	204	let mut block = block;
...	...	@@ -440,7 +491,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
440	491	&fake_borrow_temps,
441	492	scrutinee_span,
442	493	Some((arm, match_scope)),
443		false,
	494	EmitStorageLive::Yes,
444	495	);
445	496
446	497	this.fixed_temps_scope = old_dedup_scope;
...	...	@@ -485,7 +536,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
485	536	fake_borrow_temps: &[(Place<'tcx>, Local, FakeBorrowKind)],
486	537	scrutinee_span: Span,
487	538	arm_match_scope: Option<(&Arm<'tcx>, region::Scope)>,
488		storages_alive: bool,
	539	emit_storage_live: EmitStorageLive,
489	540	) -> BasicBlock {
490	541	if candidate.subcandidates.is_empty() {
491	542	// Avoid generating another `BasicBlock` when we only have one
...	...	@@ -496,8 +547,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
496	547	fake_borrow_temps,
497	548	scrutinee_span,
498	549	arm_match_scope,
499		true,
500		storages_alive,
	550	ScheduleDrops::Yes,
	551	emit_storage_live,
501	552	)
502	553	} else {
503	554	// It's helpful to avoid scheduling drops multiple times to save
...	...	@@ -515,7 +566,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
515	566	// To handle this we instead unschedule it's drop after each time
516	567	// we lower the guard.
517	568	let target_block = self.cfg.start_new_block();
518		let mut schedule_drops = true;
	569	let mut schedule_drops = ScheduleDrops::Yes;
519	570	let arm = arm_match_scope.unzip().0;
520	571	// We keep a stack of all of the bindings and type ascriptions
521	572	// from the parent candidates that we visit, that also need to
...	...	@@ -534,10 +585,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
534	585	scrutinee_span,
535	586	arm_match_scope,
536	587	schedule_drops,
537		storages_alive,
	588	emit_storage_live,
538	589	);
539	590	if arm.is_none() {
540		schedule_drops = false;
	591	schedule_drops = ScheduleDrops::No;
541	592	}
542	593	self.cfg.goto(binding_end, outer_source_info, target_block);
543	594	},
...	...	@@ -563,8 +614,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
563	614	match irrefutable_pat.kind {
564	615	// Optimize the case of `let x = ...` to write directly into `x`
565	616	PatKind::Binding { mode: BindingMode(ByRef::No, _), var, subpattern: None, .. } => {
566		let place =
567		self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
	617	let place = self.storage_live_binding(
	618	block,
	619	var,
	620	irrefutable_pat.span,
	621	OutsideGuard,
	622	ScheduleDrops::Yes,
	623	);
568	624	unpack!(block = self.expr_into_dest(place, block, initializer_id));
569	625
570	626	// Inject a fake read, see comments on `FakeReadCause::ForLet`.
...	...	@@ -597,8 +653,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
597	653	},
598	654	ascription: thir::Ascription { ref annotation, variance: _ },
599	655	} => {
600		let place =
601		self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
	656	let place = self.storage_live_binding(
	657	block,
	658	var,
	659	irrefutable_pat.span,
	660	OutsideGuard,
	661	ScheduleDrops::Yes,
	662	);
602	663	unpack!(block = self.expr_into_dest(place, block, initializer_id));
603	664
604	665	// Inject a fake read, see comments on `FakeReadCause::ForLet`.
...	...	@@ -704,7 +765,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
704	765	&[],
705	766	irrefutable_pat.span,
706	767	None,
707		false,
	768	EmitStorageLive::Yes,
708	769	)
709	770	.unit()
710	771	}
...	...	@@ -780,13 +841,15 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
780	841	}
781	842	}
782	843
	844	/// Emits a [`StatementKind::StorageLive`] for the given var, and also
	845	/// schedules a drop if requested (and possible).
783	846	pub(crate) fn storage_live_binding(
784	847	&mut self,
785	848	block: BasicBlock,
786	849	var: LocalVarId,
787	850	span: Span,
788	851	for_guard: ForGuard,
789		schedule_drop: bool,
	852	schedule_drop: ScheduleDrops,
790	853	) -> Place<'tcx> {
791	854	let local_id = self.var_local_id(var, for_guard);
792	855	let source_info = self.source_info(span);
...	...	@@ -794,7 +857,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
794	857	// Although there is almost always scope for given variable in corner cases
795	858	// like #92893 we might get variable with no scope.
796	859	if let Some(region_scope) = self.region_scope_tree.var_scope(var.0.local_id)
797		&& schedule_drop
	860	&& matches!(schedule_drop, ScheduleDrops::Yes)
798	861	{
799	862	self.schedule_drop(span, region_scope, local_id, DropKind::Storage);
800	863	}
...	...	@@ -1991,8 +2054,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
1991	2054	// Pat binding - used for `let` and function parameters as well.
1992	2055
1993	2056	impl<'a, 'tcx> Builder<'a, 'tcx> {
1994		/// If the bindings have already been declared, set `declare_bindings` to
1995		/// `false` to avoid duplicated bindings declaration; used for if-let guards.
	2057	/// Lowers a `let` expression that appears in a suitable context
	2058	/// (e.g. an `if` condition or match guard).
	2059	///
	2060	/// Also used for lowering let-else statements, since they have similar
	2061	/// needs despite not actually using `let` expressions.
	2062	///
	2063	/// Use [`DeclareLetBindings`] to control whether the `let` bindings are
	2064	/// declared or not.
1996	2065	pub(crate) fn lower_let_expr(
1997	2066	&mut self,
1998	2067	mut block: BasicBlock,
...	...	@@ -2000,8 +2069,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2000	2069	pat: &Pat<'tcx>,
2001	2070	source_scope: Option<SourceScope>,
2002	2071	scope_span: Span,
2003		declare_bindings: bool,
2004		storages_alive: bool,
	2072	declare_let_bindings: DeclareLetBindings,
	2073	emit_storage_live: EmitStorageLive,
2005	2074	) -> BlockAnd<()> {
2006	2075	let expr_span = self.thir[expr_id].span;
2007	2076	let scrutinee = unpack!(block = self.lower_scrutinee(block, expr_id, expr_span));
...	...	@@ -2017,10 +2086,22 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2017	2086
2018	2087	self.break_for_else(otherwise_block, self.source_info(expr_span));
2019	2088
2020		if declare_bindings {
2021		let expr_place = scrutinee.try_to_place(self);
2022		let opt_expr_place = expr_place.as_ref().map(\|place\| (Some(place), expr_span));
2023		self.declare_bindings(source_scope, pat.span.to(scope_span), pat, None, opt_expr_place);
	2089	match declare_let_bindings {
	2090	DeclareLetBindings::Yes => {
	2091	let expr_place = scrutinee.try_to_place(self);
	2092	let opt_expr_place = expr_place.as_ref().map(\|place\| (Some(place), expr_span));
	2093	self.declare_bindings(
	2094	source_scope,
	2095	pat.span.to(scope_span),
	2096	pat,
	2097	None,
	2098	opt_expr_place,
	2099	);
	2100	}
	2101	DeclareLetBindings::No => {} // Caller is responsible for bindings.
	2102	DeclareLetBindings::LetNotPermitted => {
	2103	self.tcx.dcx().span_bug(expr_span, "let expression not expected in this context")
	2104	}
2024	2105	}
2025	2106
2026	2107	let success = self.bind_pattern(
...	...	@@ -2029,7 +2110,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2029	2110	&[],
2030	2111	expr_span,
2031	2112	None,
2032		storages_alive,
	2113	emit_storage_live,
2033	2114	);
2034	2115
2035	2116	// If branch coverage is enabled, record this branch.
...	...	@@ -2053,8 +2134,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2053	2134	fake_borrows: &[(Place<'tcx>, Local, FakeBorrowKind)],
2054	2135	scrutinee_span: Span,
2055	2136	arm_match_scope: Option<(&Arm<'tcx>, region::Scope)>,
2056		schedule_drops: bool,
2057		storages_alive: bool,
	2137	schedule_drops: ScheduleDrops,
	2138	emit_storage_live: EmitStorageLive,
2058	2139	) -> BasicBlock {
2059	2140	debug!("bind_and_guard_matched_candidate(candidate={:?})", candidate);
2060	2141
...	...	@@ -2203,7 +2284,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2203	2284	guard,
2204	2285	None, // Use `self.local_scope()` as the temp scope
2205	2286	this.source_info(arm.span),
2206		false, // For guards, `let` bindings are declared separately
	2287	DeclareLetBindings::No, // For guards, `let` bindings are declared separately
2207	2288	)
2208	2289	});
2209	2290
...	...	@@ -2264,12 +2345,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2264	2345	let cause = FakeReadCause::ForGuardBinding;
2265	2346	self.cfg.push_fake_read(post_guard_block, guard_end, cause, Place::from(local_id));
2266	2347	}
2267		assert!(schedule_drops, "patterns with guards must schedule drops");
	2348	assert_matches!(
	2349	schedule_drops,
	2350	ScheduleDrops::Yes,
	2351	"patterns with guards must schedule drops"
	2352	);
2268	2353	self.bind_matched_candidate_for_arm_body(
2269	2354	post_guard_block,
2270		true,
	2355	ScheduleDrops::Yes,
2271	2356	by_value_bindings,
2272		storages_alive,
	2357	emit_storage_live,
2273	2358	);
2274	2359
2275	2360	post_guard_block
...	...	@@ -2281,7 +2366,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2281	2366	block,
2282	2367	schedule_drops,
2283	2368	bindings,
2284		storages_alive,
	2369	emit_storage_live,
2285	2370	);
2286	2371	block
2287	2372	}
...	...	@@ -2317,7 +2402,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2317	2402	fn bind_matched_candidate_for_guard<'b>(
2318	2403	&mut self,
2319	2404	block: BasicBlock,
2320		schedule_drops: bool,
	2405	schedule_drops: ScheduleDrops,
2321	2406	bindings: impl IntoIterator<Item = &'b Binding<'tcx>>,
2322	2407	) where
2323	2408	'tcx: 'b,
...	...	@@ -2370,9 +2455,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2370	2455	fn bind_matched_candidate_for_arm_body<'b>(
2371	2456	&mut self,
2372	2457	block: BasicBlock,
2373		schedule_drops: bool,
	2458	schedule_drops: ScheduleDrops,
2374	2459	bindings: impl IntoIterator<Item = &'b Binding<'tcx>>,
2375		storages_alive: bool,
	2460	emit_storage_live: EmitStorageLive,
2376	2461	) where
2377	2462	'tcx: 'b,
2378	2463	{
...	...	@@ -2382,21 +2467,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
2382	2467	// Assign each of the bindings. This may trigger moves out of the candidate.
2383	2468	for binding in bindings {
2384	2469	let source_info = self.source_info(binding.span);
2385		let local = if storages_alive {
	2470	let local = match emit_storage_live {
2386	2471	// Here storages are already alive, probably because this is a binding
2387	2472	// from let-else.
2388	2473	// We just need to schedule drop for the value.
2389		self.var_local_id(binding.var_id, OutsideGuard).into()
2390		} else {
2391		self.storage_live_binding(
	2474	EmitStorageLive::No => self.var_local_id(binding.var_id, OutsideGuard).into(),
	2475	EmitStorageLive::Yes => self.storage_live_binding(
2392	2476	block,
2393	2477	binding.var_id,
2394	2478	binding.span,
2395	2479	OutsideGuard,
2396	2480	schedule_drops,
2397		)
	2481	),
2398	2482	};
2399		if schedule_drops {
	2483	if matches!(schedule_drops, ScheduleDrops::Yes) {
2400	2484	self.schedule_drop_for_binding(binding.var_id, binding.span, OutsideGuard);
2401	2485	}
2402	2486	let rvalue = match binding.binding_mode.0 {

compiler/rustc_mir_transform/src/coverage/mappings.rs+5-7

...	...	@@ -9,9 +9,8 @@ use rustc_middle::ty::TyCtxt;
9	9	use rustc_span::Span;
10	10
11	11	use crate::coverage::graph::{BasicCoverageBlock, CoverageGraph, START_BCB};
12		use crate::coverage::spans::{
13		extract_refined_covspans, unexpand_into_body_span_with_visible_macro,
14		};
	12	use crate::coverage::spans::extract_refined_covspans;
	13	use crate::coverage::unexpand::unexpand_into_body_span;
15	14	use crate::coverage::ExtractedHirInfo;
16	15
17	16	/// Associates an ordinary executable code span with its corresponding BCB.
...	...	@@ -202,8 +201,7 @@ pub(super) fn extract_branch_pairs(
202	201	if !raw_span.ctxt().outer_expn_data().is_root() {
203	202	return None;
204	203	}
205		let (span, _) =
206		unexpand_into_body_span_with_visible_macro(raw_span, hir_info.body_span)?;
	204	let span = unexpand_into_body_span(raw_span, hir_info.body_span)?;
207	205
208	206	let bcb_from_marker =
209	207	\|marker: BlockMarkerId\| basic_coverage_blocks.bcb_from_bb(block_markers[marker]?);
...	...	@@ -238,7 +236,7 @@ pub(super) fn extract_mcdc_mappings(
238	236	if !raw_span.ctxt().outer_expn_data().is_root() {
239	237	return None;
240	238	}
241		let (span, _) = unexpand_into_body_span_with_visible_macro(raw_span, body_span)?;
	239	let span = unexpand_into_body_span(raw_span, body_span)?;
242	240
243	241	let true_bcb = bcb_from_marker(true_marker)?;
244	242	let false_bcb = bcb_from_marker(false_marker)?;
...	...	@@ -261,7 +259,7 @@ pub(super) fn extract_mcdc_mappings(
261	259
262	260	mcdc_decisions.extend(branch_info.mcdc_decision_spans.iter().filter_map(
263	261	\|decision: &mir::coverage::MCDCDecisionSpan\| {
264		let (span, _) = unexpand_into_body_span_with_visible_macro(decision.span, body_span)?;
	262	let span = unexpand_into_body_span(decision.span, body_span)?;
265	263
266	264	let end_bcbs = decision
267	265	.end_markers

compiler/rustc_mir_transform/src/coverage/mod.rs+1

...	...	@@ -6,6 +6,7 @@ mod mappings;
6	6	mod spans;
7	7	#[cfg(test)]
8	8	mod tests;
	9	mod unexpand;
9	10
10	11	use rustc_middle::mir::coverage::{
11	12	CodeRegion, CoverageKind, DecisionInfo, FunctionCoverageInfo, Mapping, MappingKind,

compiler/rustc_mir_transform/src/coverage/spans.rs-5

...	...	@@ -14,11 +14,6 @@ use crate::coverage::ExtractedHirInfo;
14	14
15	15	mod from_mir;
16	16
17		// FIXME(#124545) It's awkward that we have to re-export this, because it's an
18		// internal detail of `from_mir` that is also needed when handling branch and
19		// MC/DC spans. Ideally we would find a more natural home for it.
20		pub(super) use from_mir::unexpand_into_body_span_with_visible_macro;
21
22	17	pub(super) fn extract_refined_covspans(
23	18	mir_body: &mir::Body<'_>,
24	19	hir_info: &ExtractedHirInfo,

compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs+2-54

...	...	@@ -4,12 +4,13 @@ use rustc_middle::mir::{
4	4	self, AggregateKind, FakeReadCause, Rvalue, Statement, StatementKind, Terminator,
5	5	TerminatorKind,
6	6	};
7		use rustc_span::{ExpnKind, MacroKind, Span, Symbol};
	7	use rustc_span::{Span, Symbol};
8	8
9	9	use crate::coverage::graph::{
10	10	BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph, START_BCB,
11	11	};
12	12	use crate::coverage::spans::Covspan;
	13	use crate::coverage::unexpand::unexpand_into_body_span_with_visible_macro;
13	14	use crate::coverage::ExtractedHirInfo;
14	15
15	16	pub(crate) struct ExtractedCovspans {
...	...	@@ -215,59 +216,6 @@ fn filtered_terminator_span(terminator: &Terminator<'_>) -> Option<Span> {
215	216	}
216	217	}
217	218
218		/// Returns an extrapolated span (pre-expansion[^1]) corresponding to a range
219		/// within the function's body source. This span is guaranteed to be contained
220		/// within, or equal to, the `body_span`. If the extrapolated span is not
221		/// contained within the `body_span`, `None` is returned.
222		///
223		/// [^1]Expansions result from Rust syntax including macros, syntactic sugar,
224		/// etc.).
225		pub(crate) fn unexpand_into_body_span_with_visible_macro(
226		original_span: Span,
227		body_span: Span,
228		) -> Option<(Span, Option<Symbol>)> {
229		let (span, prev) = unexpand_into_body_span_with_prev(original_span, body_span)?;
230
231		let visible_macro = prev
232		.map(\|prev\| match prev.ctxt().outer_expn_data().kind {
233		ExpnKind::Macro(MacroKind::Bang, name) => Some(name),
234		_ => None,
235		})
236		.flatten();
237
238		Some((span, visible_macro))
239		}
240
241		/// Walks through the expansion ancestors of `original_span` to find a span that
242		/// is contained in `body_span` and has the same [`SyntaxContext`] as `body_span`.
243		/// The ancestor that was traversed just before the matching span (if any) is
244		/// also returned.
245		///
246		/// For example, a return value of `Some((ancestor, Some(prev))` means that:
247		/// - `ancestor == original_span.find_ancestor_inside_same_ctxt(body_span)`
248		/// - `ancestor == prev.parent_callsite()`
249		///
250		/// [`SyntaxContext`]: rustc_span::SyntaxContext
251		fn unexpand_into_body_span_with_prev(
252		original_span: Span,
253		body_span: Span,
254		) -> Option<(Span, Option<Span>)> {
255		let mut prev = None;
256		let mut curr = original_span;
257
258		while !body_span.contains(curr) \|\| !curr.eq_ctxt(body_span) {
259		prev = Some(curr);
260		curr = curr.parent_callsite()?;
261		}
262
263		debug_assert_eq!(Some(curr), original_span.find_ancestor_in_same_ctxt(body_span));
264		if let Some(prev) = prev {
265		debug_assert_eq!(Some(curr), prev.parent_callsite());
266		}
267
268		Some((curr, prev))
269		}
270
271	219	#[derive(Debug)]
272	220	pub(crate) struct Hole {
273	221	pub(crate) span: Span,

compiler/rustc_mir_transform/src/coverage/unexpand.rs created+60

...	...	@@ -0,0 +1,60 @@
	1	use rustc_span::{ExpnKind, MacroKind, Span, Symbol};
	2
	3	/// Walks through the expansion ancestors of `original_span` to find a span that
	4	/// is contained in `body_span` and has the same [syntax context] as `body_span`.
	5	pub(crate) fn unexpand_into_body_span(original_span: Span, body_span: Span) -> Option<Span> {
	6	// Because we don't need to return any extra ancestor information,
	7	// we can just delegate directly to `find_ancestor_inside_same_ctxt`.
	8	original_span.find_ancestor_inside_same_ctxt(body_span)
	9	}
	10
	11	/// Walks through the expansion ancestors of `original_span` to find a span that
	12	/// is contained in `body_span` and has the same [syntax context] as `body_span`.
	13	///
	14	/// If the returned span represents a bang-macro invocation (e.g. `foo!(..)`),
	15	/// the returned symbol will be the name of that macro (e.g. `foo`).
	16	pub(crate) fn unexpand_into_body_span_with_visible_macro(
	17	original_span: Span,
	18	body_span: Span,
	19	) -> Option<(Span, Option<Symbol>)> {
	20	let (span, prev) = unexpand_into_body_span_with_prev(original_span, body_span)?;
	21
	22	let visible_macro = prev
	23	.map(\|prev\| match prev.ctxt().outer_expn_data().kind {
	24	ExpnKind::Macro(MacroKind::Bang, name) => Some(name),
	25	_ => None,
	26	})
	27	.flatten();
	28
	29	Some((span, visible_macro))
	30	}
	31
	32	/// Walks through the expansion ancestors of `original_span` to find a span that
	33	/// is contained in `body_span` and has the same [syntax context] as `body_span`.
	34	/// The ancestor that was traversed just before the matching span (if any) is
	35	/// also returned.
	36	///
	37	/// For example, a return value of `Some((ancestor, Some(prev)))` means that:
	38	/// - `ancestor == original_span.find_ancestor_inside_same_ctxt(body_span)`
	39	/// - `prev.parent_callsite() == ancestor`
	40	///
	41	/// [syntax context]: rustc_span::SyntaxContext
	42	fn unexpand_into_body_span_with_prev(
	43	original_span: Span,
	44	body_span: Span,
	45	) -> Option<(Span, Option<Span>)> {
	46	let mut prev = None;
	47	let mut curr = original_span;
	48
	49	while !body_span.contains(curr) \|\| !curr.eq_ctxt(body_span) {
	50	prev = Some(curr);
	51	curr = curr.parent_callsite()?;
	52	}
	53
	54	debug_assert_eq!(Some(curr), original_span.find_ancestor_inside_same_ctxt(body_span));
	55	if let Some(prev) = prev {
	56	debug_assert_eq!(Some(curr), prev.parent_callsite());
	57	}
	58
	59	Some((curr, prev))
	60	}

library/core/src/fmt/mod.rs+1-2

...	...	@@ -2484,8 +2484,7 @@ impl Display for char {
2484	2484	#[stable(feature = "rust1", since = "1.0.0")]
2485	2485	impl<T: ?Sized> Pointer for *const T {
2486	2486	fn fmt(&self, f: &mut Formatter<'_>) -> Result {
2487		// Cast is needed here because `.expose_provenance()` requires `T: Sized`.
2488		pointer_fmt_inner((self as const ()).expose_provenance(), f)
	2487	pointer_fmt_inner(self.expose_provenance(), f)
2489	2488	}
2490	2489	}
2491	2490

library/core/src/intrinsics/simd.rs-3

...	...	@@ -263,9 +263,6 @@ extern "rust-intrinsic" {
263	263	///
264	264	/// `V` must be a vector of integers with the same length as `T` (but any element size).
265	265	///
266		/// `idx` must be a constant: either naming a constant item, or an inline
267		/// `const {}` expression.
268		///
269	266	/// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, read the pointer.
270	267	/// Otherwise if the corresponding value in `mask` is `0`, return the corresponding value from
271	268	/// `val`.

src/doc/rustc/src/platform-support/loongarch-linux.md+91-48

...	...	@@ -1,30 +1,24 @@
1		# loongarch\-unknown-linux-\
	1	# `loongarch-unknown-linux-`
2	2
3		Tier: 2
	3	Tier: 2 (with Host Tools)
4	4
5		[LoongArch] is a new RISC ISA developed by Loongson Technology Corporation Limited.
	5	[LoongArch][la-docs] Linux targets.
	6	LoongArch is a RISC ISA developed by Loongson Technology Corporation Limited.
6	7
7		[LoongArch]: https://loongson.github.io/LoongArch-Documentation/README-EN.html
	8	\| Target \| Description \|
	9	\|--------\|-------------\|
	10	\| `loongarch64-unknown-linux-gnu` \| LoongArch64 Linux, LP64D ABI (kernel 5.19, glibc 2.36) \|
	11	\| `loongarch64-unknown-linux-musl` \| LoongArch64 Linux, LP64D ABI (kernel 5.19, musl 1.2.5) \|
8	12
9		The target name follow this format: `<machine>-<vendor>-<os><fabi_suffix>`, where `<machine>` specifies the CPU family/model, `<vendor>` specifies the vendor and `<os>` the operating system name.
10		While the integer base ABI is implied by the machine field, the floating point base ABI type is encoded into the os field of the specifier using the string suffix `<fabi-suffix>`.
	13	These support both native and cross builds, and have full support for `std`.
11	14
12		\| `<fabi-suffix>` \| `Description` \|
13		\|------------------------\|--------------------------------------------------------------------\|
14		\| f64 \| The base ABI use 64-bits FPRs for parameter passing. (lp64d)\|
15		\| f32 \| The base ABI uses 32-bit FPRs for parameter passing. (lp64f)\|
16		\| sf \| The base ABI uses no FPR for parameter passing. (lp64s) \|
	15	Reference material:
17	16
18		<br>
	17	* [LoongArch ISA manuals][la-docs]
	18	* [Application Binary Interface for the LoongArch™ Architecture][la-abi-specs]
19	19
20		\|`ABI type(Base ABI/ABI extension)`\| `C library` \| `kernel` \| `target tuple` \|
21		\|----------------------------------\|-------------\|----------\|----------------------------------\|
22		\| lp64d/base \| glibc \| linux \| loongarch64-unknown-linux-gnu \|
23		\| lp64f/base \| glibc \| linux \| loongarch64-unknown-linux-gnuf32 \|
24		\| lp64s/base \| glibc \| linux \| loongarch64-unknown-linux-gnusf \|
25		\| lp64d/base \| musl libc \| linux \| loongarch64-unknown-linux-musl\|
26		\| lp64f/base \| musl libc \| linux \| loongarch64-unknown-linux-muslf32\|
27		\| lp64s/base \| musl libc \| linux \| loongarch64-unknown-linux-muslsf \|
	20	[la-abi-specs]: https://github.com/loongson/la-abi-specs
	21	[la-docs]: https://loongson.github.io/LoongArch-Documentation/README-EN.html
28	22
29	23	## Target maintainers
30	24
...	...	@@ -35,23 +29,57 @@ While the integer base ABI is implied by the machine field, the floating po
35	29
36	30	## Requirements
37	31
38		This target is cross-compiled.
39		A GNU toolchain for LoongArch target is required. It can be downloaded from https://github.com/loongson/build-tools/releases, or built from the source code of GCC (12.1.0 or later) and Binutils (2.40 or later).
	32	### OS Version
40	33
41		## Building the target
	34	The minimum supported Linux version is 5.19.
42	35
43		The target can be built by enabling it for a `rustc` build.
	36	Some Linux distributions, mostly commercial ones, may provide forked Linux
	37	kernels that has a version number less than 5.19 for their LoongArch ports.
	38	Such kernels may still get patched to be compatible with the upstream Linux
	39	5.19 UAPI, therefore supporting the targets described in this document, but
	40	this is not always the case. The `rustup` installer contains a check for this,
	41	and will abort if incompatibility is detected.
	42
	43	### Host toolchain
	44
	45	The targets require a reasonably up-to-date LoongArch toolchain on the host.
	46	Currently the following components are used by the Rust CI to build the target,
	47	and the versions can be seen as the minimum requirement:
	48
	49	* GNU Binutils 2.40
	50	* GCC 13.x
	51	* glibc 2.36
	52	* linux-headers 5.19
	53
	54	Of these, glibc and linux-headers are at their respective earliest versions with
	55	mainline LoongArch support, so it is impossible to use older versions of these.
	56	Older versions of Binutils and GCC will not work either, due to lack of support
	57	for newer LoongArch ELF relocation types, among other features.
	58
	59	Recent LLVM/Clang toolchains may be able to build the targets, but are not
	60	currently being actively tested.
	61
	62	## Building
	63
	64	These targets are distributed through `rustup`, and otherwise require no
	65	special configuration.
	66
	67	If you need to build your own Rust for some reason though, the targets can be
	68	simply enabled in `config.toml`. For example:
44	69
45	70	```toml
46	71	[build]
47	72	target = ["loongarch64-unknown-linux-gnu"]
48	73	```
49	74
50		Make sure `loongarch64-unknown-linux-gnu-gcc` can be searched from the directories specified in`$PATH`. Alternatively, you can use GNU LoongArch Toolchain by adding the following to `config.toml`:
	75	Make sure the LoongArch toolchain binaries are reachable from `$PATH`.
	76	Alternatively, you can explicitly configure the paths in `config.toml`:
51	77
52	78	```toml
53	79	[target.loongarch64-unknown-linux-gnu]
54		# ADJUST THIS PATH TO POINT AT YOUR TOOLCHAIN
	80	# Adjust the paths to point at your toolchain
	81	# Suppose the toolchain is placed at /TOOLCHAIN_PATH, and the cross prefix is
	82	# "loongarch64-unknown-linux-gnu-":
55	83	cc = "/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-gcc"
56	84	cxx = "/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-g++"
57	85	ar = "/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-ar"
...	...	@@ -59,36 +87,51 @@ ranlib = "/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-ranlib"
59	87	linker = "/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-gcc"
60	88	```
61	89
62		## Cross-compilation
	90	### Cross-compilation
63	91
64		This target can be cross-compiled on a `x86_64-unknown-linux-gnu` host. Cross-compilation on other hosts may work but is not tested.
	92	This target can be cross-compiled on a `x86_64-unknown-linux-gnu` host.
	93	Other hosts are also likely to work, but not actively tested.
	94
	95	You can test the cross build directly on the host, thanks to QEMU linux-user emulation.
	96	An example is given below:
	97
	98	```sh
	99	# Suppose the cross toolchain is placed at $TOOLCHAIN_PATH, with a cross prefix
	100	# of "loongarch64-unknown-linux-gnu-".
	101	export CC_loongarch64_unknown_linux_gnu="$TOOLCHAIN_PATH"/bin/loongarch64-unknown-linux-gnu-gcc
	102	export CXX_loongarch64_unknown_linux_gnu="$TOOLCHAIN_PATH"/bin/loongarch64-unknown-linux-gnu-g++
	103	export AR_loongarch64_unknown_linux_gnu="$TOOLCHAIN_PATH"/bin/loongarch64-unknown-linux-gnu-gcc-ar
	104	export CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_LINKER="$TOOLCHAIN_PATH"/bin/loongarch64-unknown-linux-gnu-gcc
	105
	106	# Point qemu-loongarch64 to the LoongArch sysroot.
	107	# Suppose the sysroot is located at "sysroot" below the toolchain root:
	108	export CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNU_RUNNER="qemu-loongarch64 -L $TOOLCHAIN_PATH/sysroot"
	109	# Or alternatively, if binfmt_misc is set up for running LoongArch binaries
	110	# transparently:
	111	export QEMU_LD_PREFIX="$TOOLCHAIN_PATH"/sysroot
65	112
66		## Testing
67		To test a cross-compiled binary on your build system, install the qemu binary that supports the LoongArch architecture and execute the following commands.
68		```text
69		CC_loongarch64_unknown_linux_gnu=/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-gcc \
70		CXX_loongarch64_unknown_linux_gnu=/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-g++ \
71		AR_loongarch64_unknown_linux_gnu=/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-gcc-ar \
72		CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNUN_LINKER=/TOOLCHAIN_PATH/bin/loongarch64-unknown-linux-gnu-gcc \
73		# SET TARGET SYSTEM LIBRARY PATH
74		CARGO_TARGET_LOONGARCH64_UNKNOWN_LINUX_GNUN_RUNNER="qemu-loongarch64 -L /TOOLCHAIN_PATH/TARGET_LIBRARY_PATH" \
75	113	cargo run --target loongarch64-unknown-linux-gnu --release
76	114	```
77		Tested on x86 architecture, other architectures not tested.
78	115
79		## Building Rust programs
	116	## Testing
	117
	118	There are no special requirements for testing and running the targets.
	119	For testing cross builds on the host, please refer to the "Cross-compilation"
	120	section above.
80	121
81		Rust does not yet ship pre-compiled artifacts for this target. To compile for this target, you will either need to build Rust with the target enabled (see "Building the target" above), or build your own copy of `std` by using `build-std` or similar.
	122	## Building Rust programs
82	123
83		If `rustc` has support for that target and the library artifacts are available, then Rust static libraries can be built for that target:
	124	As the targets are available through `rustup`, it is very easy to build Rust
	125	programs for these targets: same as with other architectures.
	126	Note that you will need a LoongArch C/C++ toolchain for linking, or if you want
	127	to compile C code along with Rust (such as for Rust crates with C dependencies).
84	128
85		```shell
86		$ rustc --target loongarch64-unknown-linux-gnu your-code.rs --crate-type staticlib
87		$ ls libyour_code.a
	129	```sh
	130	rustup target add loongarch64-unknown-linux-gnu
	131	cargo build --target loongarch64-unknown-linux-gnu
88	132	```
89	133
90		On Rust Nightly it's possible to build without the target artifacts available:
	134	Availability of pre-built artifacts through `rustup` are as follows:
91	135
92		```text
93		cargo build -Z build-std --target loongarch64-unknown-linux-gnu
94		```
	136	* `loongarch64-unknown-linux-gnu`: since Rust 1.71;
	137	* `loongarch64-unknown-linux-musl`: since Rust 1.81.

src/doc/rustc/src/platform-support/loongarch-none.md+34-22

...	...	@@ -4,10 +4,10 @@
4	4
5	5	Freestanding/bare-metal LoongArch64 binaries in ELF format: firmware, kernels, etc.
6	6
7		\| Target \| Descriptions \|
8		\|------------------------------------\|-------------------------------------------------------\|
9		\| loongarch64-unknown-none \| LoongArch 64-bit, LP64D ABI (freestanding, hardfloat) \|
10		\| loongarch64-unknown-none-softfloat \| LoongArch 64-bit, LP64S ABI (freestanding, softfloat) \|
	7	\| Target \| Description \|
	8	\|--------\|-------------\|
	9	\| `loongarch64-unknown-none` \| LoongArch 64-bit, LP64D ABI (freestanding, hard-float) \|
	10	\| `loongarch64-unknown-none-softfloat` \| LoongArch 64-bit, LP64S ABI (freestanding, soft-float) \|
11	11
12	12	## Target maintainers
13	13
...	...	@@ -19,6 +19,8 @@ Freestanding/bare-metal LoongArch64 binaries in ELF format: firmware, kernels, e
19	19	This target is cross-compiled. There is no support for `std`. There is no
20	20	default allocator, but it's possible to use `alloc` by supplying an allocator.
21	21
	22	The `*-softfloat` target does not assume existence of FPU or any other LoongArch
	23	ISA extension, and does not make use of any non-GPR register.
22	24	This allows the generated code to run in environments, such as kernels, which
23	25	may need to avoid the use of such registers or which may have special considerations
24	26	about the use of such registers (e.g. saving and restoring them to avoid breaking
...	...	@@ -26,54 +28,64 @@ userspace code using the same registers). You can change code generation to use
26	28	additional CPU features via the `-C target-feature=` codegen options to rustc, or
27	29	via the `#[target_feature]` mechanism within Rust code.
28	30
29		By default, code generated with this target should run on any `loongarch`
30		hardware; enabling additional target features may raise this baseline.
	31	By default, code generated with the soft-float target should run on any
	32	LoongArch64 hardware, with the hard-float target additionally requiring an FPU;
	33	enabling additional target features may raise this baseline.
31	34
32		Code generated with this target will use the `small` code model by default.
	35	Code generated with the targets will use the `small` code model by default.
33	36	You can change this using the `-C code-model=` option to rustc.
34	37
35		On `loongarch64-unknown-none*`, `extern "C"` uses the [standard calling
36		convention](https://loongson.github.io/LoongArch-Documentation/LoongArch-ELF-ABI-EN.html).
	38	On `loongarch64-unknown-none*`, `extern "C"` uses the [architecture's standard calling convention][lapcs].
37	39
38		This target generates binaries in the ELF format. Any alternate formats or
	40	[lapcs]: https://github.com/loongson/la-abi-specs/blob/release/lapcs.adoc
	41
	42	The targets generate binaries in the ELF format. Any alternate formats or
39	43	special considerations for binary layout will require linker options or linker
40	44	scripts.
41	45
42	46	## Building the target
43	47
44		You can build Rust with support for the target by adding it to the `target`
	48	You can build Rust with support for the targets by adding them to the `target`
45	49	list in `config.toml`:
46	50
47	51	```toml
48	52	[build]
49	53	build-stage = 1
50		target = ["loongarch64-unknown-none"]
	54	target = [
	55	"loongarch64-unknown-none",
	56	"loongarch64-unknown-none-softfloat",
	57	]
51	58	```
52	59
	60	## Testing
	61
	62	As the targets support a variety of different environments and do not support
	63	`std`, they do not support running the Rust test suite.
	64
53	65	## Building Rust programs
54	66
55		```text
	67	Starting with Rust 1.74, precompiled artifacts are provided via `rustup`:
	68
	69	```sh
	70	# install cross-compile toolchain
	71	rustup target add loongarch64-unknown-none
56	72	# target flag may be used with any cargo or rustc command
57	73	cargo build --target loongarch64-unknown-none
58	74	```
59	75
60		## Testing
61
62		As `loongarch64-unknown-none*` supports a variety of different environments and does
63		not support `std`, this target does not support running the Rust test suite.
64
65	76	## Cross-compilation toolchains and C code
66	77
67		If you want to compile C code along with Rust (such as for Rust crates with C
68		dependencies), you will need an appropriate `loongarch` toolchain.
	78	For cross builds, you will need an appropriate LoongArch C/C++ toolchain for
	79	linking, or if you want to compile C code along with Rust (such as for Rust
	80	crates with C dependencies).
69	81
70	82	Rust may be able to use an `loongarch64-unknown-linux-gnu-` toolchain with
71	83	appropriate standalone flags to build for this toolchain (depending on the assumptions
72	84	of that toolchain, see below), or you may wish to use a separate
73	85	`loongarch64-unknown-none` toolchain.
74	86
75		On some `loongarch` hosts that use ELF binaries, you may be able to use the host
	87	On some LoongArch hosts that use ELF binaries, you may be able to use the host
76	88	C toolchain, if it does not introduce assumptions about the host environment
77	89	that don't match the expectations of a standalone environment. Otherwise, you
78	90	may need a separate toolchain for standalone/freestanding development, just as
79		when cross-compiling from a non-`loongarch` platform.
	91	when cross-compiling from a non-LoongArch platform.

src/tools/run-make-support/src/lib.rs+3-2

...	...	@@ -525,11 +525,12 @@ macro_rules! impl_common_helpers {
525	525	/// Generic command arguments provider. Prefer specific helper methods if possible.
526	526	/// Note that for some executables, arguments might be platform specific. For C/C++
527	527	/// compilers, arguments might be platform and compiler specific.
528		pub fn args<S>(&mut self, args: &[S]) -> &mut Self
	528	pub fn args<V, S>(&mut self, args: V) -> &mut Self
529	529	where
	530	V: AsRef<[S]>,
530	531	S: AsRef<::std::ffi::OsStr>,
531	532	{
532		self.cmd.args(args);
	533	self.cmd.args(args.as_ref());
533	534	self
534	535	}
535	536

src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs-1

...	...	@@ -49,7 +49,6 @@ pub const DEFAULT_LINTS: &[Lint] = &[
49	49	label: "bindings_with_variant_name",
50	50	description: r##"detects pattern bindings with the same name as one of the matched variants"##,
51	51	},
52		Lint { label: "box_pointers", description: r##"use of owned (Box type) heap memory"## },
53	52	Lint {
54	53	label: "break_with_label_and_loop",
55	54	description: r##"`break` expression with label and unlabeled loop as value expression"##,

tests/run-make/arguments-non-c-like-enum/rmake.rs+2-2

...	...	@@ -10,8 +10,8 @@ pub fn main() {
10	10	cc().input("test.c")
11	11	.input(static_lib_name("nonclike"))
12	12	.out_exe("test")
13		.args(&extra_c_flags())
14		.args(&extra_cxx_flags())
	13	.args(extra_c_flags())
	14	.args(extra_cxx_flags())
15	15	.inspect(\|cmd\| eprintln!("{cmd:?}"))
16	16	.run();
17	17	run("test");

tests/run-make/c-link-to-rust-staticlib/rmake.rs+1-1

...	...	@@ -9,7 +9,7 @@ use std::fs;
9	9
10	10	fn main() {
11	11	rustc().input("foo.rs").run();
12		cc().input("bar.c").input(static_lib_name("foo")).out_exe("bar").args(&extra_c_flags()).run();
	12	cc().input("bar.c").input(static_lib_name("foo")).out_exe("bar").args(extra_c_flags()).run();
13	13	run("bar");
14	14	remove_file(static_lib_name("foo"));
15	15	run("bar");

tests/run-make/c-link-to-rust-va-list-fn/rmake.rs+1-1

...	...	@@ -12,7 +12,7 @@ fn main() {
12	12	cc().input("test.c")
13	13	.input(static_lib_name("checkrust"))
14	14	.out_exe("test")
15		.args(&extra_c_flags())
	15	.args(extra_c_flags())
16	16	.run();
17	17	run("test");
18	18	}

tests/run-make/glibc-staticlib-args/rmake.rs+2-2

...	...	@@ -11,8 +11,8 @@ fn main() {
11	11	cc().input("program.c")
12	12	.arg(static_lib_name("library"))
13	13	.out_exe("program")
14		.args(&extra_c_flags())
15		.args(&extra_cxx_flags())
	14	.args(extra_c_flags())
	15	.args(extra_cxx_flags())
16	16	.run();
17	17	run(&bin_name("program"));
18	18	}

tests/run-make/print-check-cfg/rmake.rs+2-6

...	...	@@ -86,12 +86,8 @@ fn main() {
86	86	}
87	87
88	88	fn check(CheckCfg { args, contains }: CheckCfg) {
89		let output = rustc()
90		.input("lib.rs")
91		.arg("-Zunstable-options")
92		.arg("--print=check-cfg")
93		.args(&*args)
94		.run();
	89	let output =
	90	rustc().input("lib.rs").arg("-Zunstable-options").arg("--print=check-cfg").args(args).run();
95	91
96	92	let stdout = output.stdout_utf8();
97	93

tests/run-make/return-non-c-like-enum/rmake.rs+2-2

...	...	@@ -11,8 +11,8 @@ fn main() {
11	11	cc().input("test.c")
12	12	.arg(&static_lib_name("nonclike"))
13	13	.out_exe("test")
14		.args(&extra_c_flags())
15		.args(&extra_cxx_flags())
	14	.args(extra_c_flags())
	15	.args(extra_cxx_flags())
16	16	.run();
17	17	run("test");
18	18	}

tests/run-make/textrel-on-minimal-lib/rmake.rs+2-2

...	...	@@ -20,8 +20,8 @@ fn main() {
20	20	.out_exe(&dynamic_lib_name("bar"))
21	21	.arg("-fPIC")
22	22	.arg("-shared")
23		.args(&extra_c_flags())
24		.args(&extra_cxx_flags())
	23	.args(extra_c_flags())
	24	.args(extra_cxx_flags())
25	25	.run();
26	26	llvm_readobj()
27	27	.input(dynamic_lib_name("bar"))

tests/ui/const-generics/repeat_expr_hack_gives_right_generics.rs+13-9

...	...	@@ -1,14 +1,18 @@
1		// Given an anon const `a`: `{ N }` and some anon const `b` which references the
2		// first anon const: `{ [1; a] }`. `b` should not have any generics as it is not
3		// a simple `N` argument nor is it a repeat expr count.
	1	// Given a const argument `a`: `{ N }` and some const argument `b` which references the
	2	// first anon const like so: `{ [1; a] }`. The `b` anon const should not be allowed to use
	3	// any generic parameters as:
	4	// - The anon const is not a simple bare parameter, e.g. `N`
	5	// - The anon const is not the length of an array repeat expression, e.g. the `N` in `[1; N]`.
4	6	//
5		// On the other hand `b` is a repeat expr count and so it should inherit its
6		// parents generics as part of the `const_evaluatable_unchecked` fcw (#76200).
	7	// On the other hand `a` is a const argument for the length of a repeat expression and
	8	// so it should inherit the generics declared on its parent definition. (This hack is
	9	// introduced for backwards compatibility and is tracked in #76200)
7	10	//
8		// In this specific case however `b`'s parent should be `a` and so it should wind
9		// up not having any generics after all. If `a` were to inherit its generics from
10		// the enclosing item then the reference to `a` from `b` would contain generic
11		// parameters not usable by `b` which would cause us to ICE.
	11	// In this specific case `a`'s parent should be `b` which does not have any generics.
	12	// This means that even though `a` inherits generics from `b`, it still winds up not having
	13	// access to any generic parameters. If `a` were to inherit its generics from the surrounding
	14	// function `foo` then the reference to `a` from `b` would contain generic parameters not usable
	15	// by `b` which would cause us to ICE.
12	16
13	17	fn bar<const N: usize>() {}
14	18

tests/ui/const-generics/repeat_expr_hack_gives_right_generics.stderr+1-1

...	...	@@ -1,5 +1,5 @@
1	1	error: generic parameters may not be used in const operations
2		--> $DIR/repeat_expr_hack_gives_right_generics.rs:16:17
	2	--> $DIR/repeat_expr_hack_gives_right_generics.rs:20:17
3	3	\|
4	4	LL \| bar::<{ [1; N] }>();
5	5	\| ^ cannot perform const operation using `N`

tests/ui/lint/lint-owned-heap-memory.rs deleted-12

...	...	@@ -1,12 +0,0 @@
1		#![allow(dead_code)]
2		#![forbid(box_pointers)]
3
4
5		struct Foo {
6		x: Box<isize> //~ ERROR type uses owned
7		}
8
9		fn main() {
10		let _x: Foo = Foo { x : Box::new(10) };
11		//~^ ERROR type uses owned
12		}

tests/ui/lint/lint-owned-heap-memory.stderr deleted-20

...	...	@@ -1,20 +0,0 @@
1		error: type uses owned (Box type) pointers: Box<isize>
2		--> $DIR/lint-owned-heap-memory.rs:6:5
3		\|
4		LL \| x: Box<isize>
5		\| ^^^^^^^^^^^^^
6		\|
7		note: the lint level is defined here
8		--> $DIR/lint-owned-heap-memory.rs:2:11
9		\|
10		LL \| #![forbid(box_pointers)]
11		\| ^^^^^^^^^^^^
12
13		error: type uses owned (Box type) pointers: Box<isize>
14		--> $DIR/lint-owned-heap-memory.rs:10:29
15		\|
16		LL \| let _x: Foo = Foo { x : Box::new(10) };
17		\| ^^^^^^^^^^^^
18
19		error: aborting due to 2 previous errors
20

tests/ui/lint/reasons-erroneous.rs+1-1

...	...	@@ -9,7 +9,7 @@
9	9	#![warn(bare_trait_objects, reasons = "leaders to no sure land, guides their bearings lost")]
10	10	//~^ ERROR malformed lint attribute
11	11	//~\| NOTE bad attribute argument
12		#![warn(box_pointers, blerp = "or in league with robbers have reversed the signposts")]
	12	#![warn(unsafe_code, blerp = "or in league with robbers have reversed the signposts")]
13	13	//~^ ERROR malformed lint attribute
14	14	//~\| NOTE bad attribute argument
15	15	#![warn(elided_lifetimes_in_paths, reason("disrespectful to ancestors", "irresponsible to heirs"))]

tests/ui/lint/reasons-erroneous.stderr+3-3

...	...	@@ -17,10 +17,10 @@ LL \| #![warn(bare_trait_objects, reasons = "leaders to no sure land, guides thei
17	17	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ bad attribute argument
18	18
19	19	error[E0452]: malformed lint attribute input
20		--> $DIR/reasons-erroneous.rs:12:23
	20	--> $DIR/reasons-erroneous.rs:12:22
21	21	\|
22		LL \| #![warn(box_pointers, blerp = "or in league with robbers have reversed the signposts")]
23		\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ bad attribute argument
	22	LL \| #![warn(unsafe_code, blerp = "or in league with robbers have reversed the signposts")]
	23	\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ bad attribute argument
24	24
25	25	error[E0452]: malformed lint attribute input
26	26	--> $DIR/reasons-erroneous.rs:15:36

tests/ui/suggestions/types/dont-suggest-path-names.rs created+17

...	...	@@ -0,0 +1,17 @@
	1	// This is a regression test for #123630
	2	//
	3	// Prior to #123703 this was resulting in compiler suggesting add a type signature
	4	// for `lit` containing path to a file containing `Select` - something obviously invalid.
	5
	6	struct Select<F, I>(F, I);
	7	fn select<F, I>(filter: F) -> Select<F, I> {}
	8	//~^ 7:31: 7:43: mismatched types [E0308]
	9
	10	fn parser1() {
	11	let lit = select(\|x\| match x {
	12	//~^ 11:23: 11:24: type annotations needed [E0282]
	13	_ => (),
	14	});
	15	}
	16
	17	fn main() {}

tests/ui/suggestions/types/dont-suggest-path-names.stderr created+26

...	...	@@ -0,0 +1,26 @@
	1	error[E0308]: mismatched types
	2	--> $DIR/dont-suggest-path-names.rs:7:31
	3	\|
	4	LL \| fn select<F, I>(filter: F) -> Select<F, I> {}
	5	\| ------ ^^^^^^^^^^^^ expected `Select<F, I>`, found `()`
	6	\| \|
	7	\| implicitly returns `()` as its body has no tail or `return` expression
	8	\|
	9	= note: expected struct `Select<F, I>`
	10	found unit type `()`
	11
	12	error[E0282]: type annotations needed
	13	--> $DIR/dont-suggest-path-names.rs:11:23
	14	\|
	15	LL \| let lit = select(\|x\| match x {
	16	\| ^ - type must be known at this point
	17	\|
	18	help: consider giving this closure parameter an explicit type
	19	\|
	20	LL \| let lit = select(\|x: /* Type */\| match x {
	21	\| ++++++++++++
	22
	23	error: aborting due to 2 previous errors
	24
	25	Some errors have detailed explanations: E0282, E0308.
	26	For more information about an error, try `rustc --explain E0282`.

author	bors <bors@rust-lang.org> 2024-06-30 20:14:40 UTC
committer	bors <bors@rust-lang.org> 2024-06-30 20:14:40 UTC
log	6868c831a1eb45c5150ff623cef5e42a8b8946d0
tree	25442147b3a5744d947f7cdbb69ab40b92e78db5
parent	ef3d6fd7002500af0a985f70d3ac5152623c1396
parent	40371973535621352543572c6f8e43978204ba9a

Auto merge of #127174 - matthiaskrgr:rollup-q87j6cn, r=matthiaskrgr