Skip to content

Commit 81857ba

Browse files
borsbors
committed
Auto merge of #125393 - matthiaskrgr:rollup-vy2yf8v, r=matthiaskrgr
Rollup of 7 pull requests Successful merges: - #124227 (Make sure that the method resolution matches in `note_source_of_type_mismatch_constraint`) - #124896 (miri: rename intrinsic_fallback_checks_ub to intrinsic_fallback_is_spec) - #125015 (Pattern types: Prohibit generic args on const params) - #125043 (reference type safety invariant docs: clarification) - #125259 (An async closure may implement `FnMut`/`Fn` if it has no self-borrows) - #125306 (Force the inner coroutine of an async closure to `move` if the outer closure is `move` and `FnOnce`) - #125378 (remove tracing tree indent lines) r? `@ghost` `@rustbot` modify labels: rollup
2 parents b54dd08 + 4c886b9 commit 81857ba

32 files changed

+343
-150
lines changed

‎compiler/rustc_hir_analysis/messages.ftl

+3-3
Original file line numberDiff line numberDiff line change
@@ -371,9 +371,9 @@ hir_analysis_pass_to_variadic_function = can't pass `{$ty}` to variadic function
371371
.suggestion = cast the value to `{$cast_ty}`
372372
.help = cast the value to `{$cast_ty}`
373373
374-
hir_analysis_pattern_type_non_const_range = "range patterns must have constant range start and end"
375-
hir_analysis_pattern_type_wild_pat = "wildcard patterns are not permitted for pattern types"
376-
.label = "this type is the same as the inner type without a pattern"
374+
hir_analysis_pattern_type_non_const_range = range patterns must have constant range start and end
375+
hir_analysis_pattern_type_wild_pat = wildcard patterns are not permitted for pattern types
376+
.label = this type is the same as the inner type without a pattern
377377
hir_analysis_placeholder_not_allowed_item_signatures = the placeholder `_` is not allowed within types on item signatures for {$kind}
378378
.label = not allowed in type signatures
379379

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -1382,7 +1382,7 @@ pub enum GenericsArgsErrExtend<'tcx> {
13821382
span: Span,
13831383
},
13841384
SelfTyParam(Span),
1385-
TyParam(DefId),
1385+
Param(DefId),
13861386
DefVariant,
13871387
None,
13881388
}
@@ -1498,11 +1498,11 @@ fn generics_args_err_extend<'a>(
14981498
GenericsArgsErrExtend::DefVariant => {
14991499
err.note("enum variants can't have type parameters");
15001500
}
1501-
GenericsArgsErrExtend::TyParam(def_id) => {
1502-
if let Some(span) = tcx.def_ident_span(def_id) {
1503-
let name = tcx.item_name(def_id);
1504-
err.span_note(span, format!("type parameter `{name}` defined here"));
1505-
}
1501+
GenericsArgsErrExtend::Param(def_id) => {
1502+
let span = tcx.def_ident_span(def_id).unwrap();
1503+
let kind = tcx.def_descr(def_id);
1504+
let name = tcx.item_name(def_id);
1505+
err.span_note(span, format!("{kind} `{name}` defined here"));
15061506
}
15071507
GenericsArgsErrExtend::SelfTyParam(span) => {
15081508
err.span_suggestion_verbose(

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

+8-3
Original file line numberDiff line numberDiff line change
@@ -1757,7 +1757,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
17571757
assert_eq!(opt_self_ty, None);
17581758
let _ = self.prohibit_generic_args(
17591759
path.segments.iter(),
1760-
GenericsArgsErrExtend::TyParam(def_id),
1760+
GenericsArgsErrExtend::Param(def_id),
17611761
);
17621762
self.lower_ty_param(hir_id)
17631763
}
@@ -2190,10 +2190,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
21902190

21912191
hir::ExprKind::Path(hir::QPath::Resolved(
21922192
_,
2193-
&hir::Path {
2194-
res: Res::Def(DefKind::ConstParam, def_id), ..
2193+
path @ &hir::Path {
2194+
res: Res::Def(DefKind::ConstParam, def_id),
2195+
..
21952196
},
21962197
)) => {
2198+
let _ = self.prohibit_generic_args(
2199+
path.segments.iter(),
2200+
GenericsArgsErrExtend::Param(def_id),
2201+
);
21972202
let ty = tcx
21982203
.type_of(def_id)
21992204
.no_bound_vars()

‎compiler/rustc_hir_typeck/src/demand.rs

+27-6
Original file line numberDiff line numberDiff line change
@@ -373,8 +373,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
373373
let Some(arg_ty) = self.node_ty_opt(args[idx].hir_id) else {
374374
return false;
375375
};
376-
let possible_rcvr_ty = expr_finder.uses.iter().find_map(|binding| {
376+
let possible_rcvr_ty = expr_finder.uses.iter().rev().find_map(|binding| {
377377
let possible_rcvr_ty = self.node_ty_opt(binding.hir_id)?;
378+
if possible_rcvr_ty.is_ty_var() {
379+
return None;
380+
}
378381
// Fudge the receiver, so we can do new inference on it.
379382
let possible_rcvr_ty = possible_rcvr_ty.fold_with(&mut fudger);
380383
let method = self
@@ -386,6 +389,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
386389
binding,
387390
)
388391
.ok()?;
392+
// Make sure we select the same method that we started with...
393+
if Some(method.def_id)
394+
!= self.typeck_results.borrow().type_dependent_def_id(call_expr.hir_id)
395+
{
396+
return None;
397+
}
389398
// Unify the method signature with our incompatible arg, to
390399
// do inference in the *opposite* direction and to find out
391400
// what our ideal rcvr ty would look like.
@@ -456,6 +465,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
456465
) else {
457466
continue;
458467
};
468+
// Make sure we select the same method that we started with...
469+
if Some(method.def_id)
470+
!= self.typeck_results.borrow().type_dependent_def_id(parent_expr.hir_id)
471+
{
472+
continue;
473+
}
459474

460475
let ideal_rcvr_ty = rcvr_ty.fold_with(&mut fudger);
461476
let ideal_method = self
@@ -505,13 +520,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
505520
// blame arg, if possible. Don't do this if we're coming from
506521
// arg mismatch code, because we'll possibly suggest a mutually
507522
// incompatible fix at the original mismatch site.
523+
// HACK(compiler-errors): We don't actually consider the implications
524+
// of our inference guesses in `emit_type_mismatch_suggestions`, so
525+
// only suggest things when we know our type error is precisely due to
526+
// a type mismatch, and not via some projection or something. See #116155.
508527
if matches!(source, TypeMismatchSource::Ty(_))
509528
&& let Some(ideal_method) = ideal_method
510-
&& let ideal_arg_ty = self.resolve_vars_if_possible(ideal_method.sig.inputs()[idx + 1])
511-
// HACK(compiler-errors): We don't actually consider the implications
512-
// of our inference guesses in `emit_type_mismatch_suggestions`, so
513-
// only suggest things when we know our type error is precisely due to
514-
// a type mismatch, and not via some projection or something. See #116155.
529+
&& Some(ideal_method.def_id)
530+
== self
531+
.typeck_results
532+
.borrow()
533+
.type_dependent_def_id(parent_expr.hir_id)
534+
&& let ideal_arg_ty =
535+
self.resolve_vars_if_possible(ideal_method.sig.inputs()[idx + 1])
515536
&& !ideal_arg_ty.has_non_region_infer()
516537
{
517538
self.emit_type_mismatch_suggestions(

‎compiler/rustc_hir_typeck/src/upvar.rs

+58-31
Original file line numberDiff line numberDiff line change
@@ -204,6 +204,60 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
204204
fake_reads: Default::default(),
205205
};
206206

207+
let _ = euv::ExprUseVisitor::new(
208+
&FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
209+
&mut delegate,
210+
)
211+
.consume_body(body);
212+
213+
// There are several curious situations with coroutine-closures where
214+
// analysis is too aggressive with borrows when the coroutine-closure is
215+
// marked `move`. Specifically:
216+
//
217+
// 1. If the coroutine-closure was inferred to be `FnOnce` during signature
218+
// inference, then it's still possible that we try to borrow upvars from
219+
// the coroutine-closure because they are not used by the coroutine body
220+
// in a way that forces a move. See the test:
221+
// `async-await/async-closures/force-move-due-to-inferred-kind.rs`.
222+
//
223+
// 2. If the coroutine-closure is forced to be `FnOnce` due to the way it
224+
// uses its upvars, but not *all* upvars would force the closure to `FnOnce`.
225+
// See the test: `async-await/async-closures/force-move-due-to-actually-fnonce.rs`.
226+
//
227+
// This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
228+
// coroutine bodies can't borrow from their parent closure. To fix this,
229+
// we force the inner coroutine to also be `move`. This only matters for
230+
// coroutine-closures that are `move` since otherwise they themselves will
231+
// be borrowing from the outer environment, so there's no self-borrows occuring.
232+
//
233+
// One *important* note is that we do a call to `process_collected_capture_information`
234+
// to eagerly test whether the coroutine would end up `FnOnce`, but we do this
235+
// *before* capturing all the closure args by-value below, since that would always
236+
// cause the analysis to return `FnOnce`.
237+
if let UpvarArgs::Coroutine(..) = args
238+
&& let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
239+
self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
240+
&& let parent_hir_id =
241+
self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
242+
&& let parent_ty = self.node_ty(parent_hir_id)
243+
&& let hir::CaptureBy::Value { move_kw } =
244+
self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause
245+
{
246+
// (1.) Closure signature inference forced this closure to `FnOnce`.
247+
if let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty) {
248+
capture_clause = hir::CaptureBy::Value { move_kw };
249+
}
250+
// (2.) The way that the closure uses its upvars means it's `FnOnce`.
251+
else if let (_, ty::ClosureKind::FnOnce, _) = self
252+
.process_collected_capture_information(
253+
capture_clause,
254+
&delegate.capture_information,
255+
)
256+
{
257+
capture_clause = hir::CaptureBy::Value { move_kw };
258+
}
259+
}
260+
207261
// As noted in `lower_coroutine_body_with_moved_arguments`, we default the capture mode
208262
// to `ByRef` for the `async {}` block internal to async fns/closure. This means
209263
// that we would *not* be moving all of the parameters into the async block by default.
@@ -253,34 +307,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
253307
}
254308
}
255309

256-
let _ = euv::ExprUseVisitor::new(
257-
&FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
258-
&mut delegate,
259-
)
260-
.consume_body(body);
261-
262-
// If a coroutine is comes from a coroutine-closure that is `move`, but
263-
// the coroutine-closure was inferred to be `FnOnce` during signature
264-
// inference, then it's still possible that we try to borrow upvars from
265-
// the coroutine-closure because they are not used by the coroutine body
266-
// in a way that forces a move.
267-
//
268-
// This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
269-
// coroutine bodies can't borrow from their parent closure. To fix this,
270-
// we force the inner coroutine to also be `move`. This only matters for
271-
// coroutine-closures that are `move` since otherwise they themselves will
272-
// be borrowing from the outer environment, so there's no self-borrows occuring.
273-
if let UpvarArgs::Coroutine(..) = args
274-
&& let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
275-
self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
276-
&& let parent_hir_id =
277-
self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
278-
&& let parent_ty = self.node_ty(parent_hir_id)
279-
&& let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty)
280-
{
281-
capture_clause = self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause;
282-
}
283-
284310
debug!(
285311
"For closure={:?}, capture_information={:#?}",
286312
closure_def_id, delegate.capture_information
@@ -289,7 +315,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
289315
self.log_capture_analysis_first_pass(closure_def_id, &delegate.capture_information, span);
290316

291317
let (capture_information, closure_kind, origin) = self
292-
.process_collected_capture_information(capture_clause, delegate.capture_information);
318+
.process_collected_capture_information(capture_clause, &delegate.capture_information);
293319

294320
self.compute_min_captures(closure_def_id, capture_information, span);
295321

@@ -545,13 +571,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
545571
fn process_collected_capture_information(
546572
&self,
547573
capture_clause: hir::CaptureBy,
548-
capture_information: InferredCaptureInformation<'tcx>,
574+
capture_information: &InferredCaptureInformation<'tcx>,
549575
) -> (InferredCaptureInformation<'tcx>, ty::ClosureKind, Option<(Span, Place<'tcx>)>) {
550576
let mut closure_kind = ty::ClosureKind::LATTICE_BOTTOM;
551577
let mut origin: Option<(Span, Place<'tcx>)> = None;
552578

553579
let processed = capture_information
554-
.into_iter()
580+
.iter()
581+
.cloned()
555582
.map(|(place, mut capture_info)| {
556583
// Apply rules for safety before inferring closure kind
557584
let (place, capture_kind) =

‎compiler/rustc_log/src/lib.rs

-1
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,6 @@ pub fn init_logger(cfg: LoggerConfig) -> Result<(), Error> {
103103

104104
let mut layer = tracing_tree::HierarchicalLayer::default()
105105
.with_writer(io::stderr)
106-
.with_indent_lines(true)
107106
.with_ansi(color_logs)
108107
.with_targets(true)
109108
.with_verbose_exit(verbose_entry_exit)

‎compiler/rustc_middle/src/ty/sty.rs

+39
Original file line numberDiff line numberDiff line change
@@ -401,6 +401,45 @@ impl<'tcx> CoroutineClosureArgs<'tcx> {
401401
pub fn coroutine_witness_ty(self) -> Ty<'tcx> {
402402
self.split().coroutine_witness_ty
403403
}
404+
405+
pub fn has_self_borrows(&self) -> bool {
406+
match self.coroutine_captures_by_ref_ty().kind() {
407+
ty::FnPtr(sig) => sig
408+
.skip_binder()
409+
.visit_with(&mut HasRegionsBoundAt { binder: ty::INNERMOST })
410+
.is_break(),
411+
ty::Error(_) => true,
412+
_ => bug!(),
413+
}
414+
}
415+
}
416+
/// Unlike `has_escaping_bound_vars` or `outermost_exclusive_binder`, this will
417+
/// detect only regions bound *at* the debruijn index.
418+
struct HasRegionsBoundAt {
419+
binder: ty::DebruijnIndex,
420+
}
421+
// FIXME: Could be optimized to not walk into components with no escaping bound vars.
422+
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HasRegionsBoundAt {
423+
type Result = ControlFlow<()>;
424+
fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
425+
&mut self,
426+
t: &ty::Binder<'tcx, T>,
427+
) -> Self::Result {
428+
self.binder.shift_in(1);
429+
t.super_visit_with(self)?;
430+
self.binder.shift_out(1);
431+
ControlFlow::Continue(())
432+
}
433+
434+
fn visit_region(&mut self, r: ty::Region<'tcx>) -> Self::Result {
435+
if let ty::ReBound(binder, _) = *r
436+
&& self.binder == binder
437+
{
438+
ControlFlow::Break(())
439+
} else {
440+
ControlFlow::Continue(())
441+
}
442+
}
404443
}
405444

406445
#[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable)]

‎compiler/rustc_pattern_analysis/tests/common/mod.rs

-1
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,6 @@ pub fn init_tracing() {
1313
use tracing_subscriber::Layer;
1414
let _ = tracing_tree::HierarchicalLayer::default()
1515
.with_writer(std::io::stderr)
16-
.with_indent_lines(true)
1716
.with_ansi(true)
1817
.with_targets(true)
1918
.with_indent_amount(2)

‎compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs

+5-8
Original file line numberDiff line numberDiff line change
@@ -300,14 +300,11 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<'tcx>(
300300
return Err(NoSolution);
301301
}
302302

303-
// If `Fn`/`FnMut`, we only implement this goal if we
304-
// have no captures.
305-
let no_borrows = match args.tupled_upvars_ty().kind() {
306-
ty::Tuple(tys) => tys.is_empty(),
307-
ty::Error(_) => false,
308-
_ => bug!("tuple_fields called on non-tuple"),
309-
};
310-
if closure_kind != ty::ClosureKind::FnOnce && !no_borrows {
303+
// A coroutine-closure implements `FnOnce` *always*, since it may
304+
// always be called once. It additionally implements `Fn`/`FnMut`
305+
// only if it has no upvars referencing the closure-env lifetime,
306+
// and if the closure kind permits it.
307+
if closure_kind != ty::ClosureKind::FnOnce && args.has_self_borrows() {
311308
return Err(NoSolution);
312309
}
313310

‎compiler/rustc_trait_selection/src/solve/search_graph.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -279,6 +279,7 @@ impl<'tcx> SearchGraph<TyCtxt<'tcx>> {
279279
};
280280

281281
if let Some(result) = self.lookup_global_cache(tcx, input, available_depth, inspect) {
282+
debug!("global cache hit");
282283
return result;
283284
}
284285

@@ -360,7 +361,7 @@ impl<'tcx> SearchGraph<TyCtxt<'tcx>> {
360361
for _ in 0..FIXPOINT_STEP_LIMIT {
361362
match self.fixpoint_step_in_task(tcx, input, inspect, &mut prove_goal) {
362363
StepResult::Done(final_entry, result) => return (final_entry, result),
363-
StepResult::HasChanged => {}
364+
StepResult::HasChanged => debug!("fixpoint changed provisional results"),
364365
}
365366
}
366367

‎compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

+3-12
Original file line numberDiff line numberDiff line change
@@ -418,20 +418,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
418418
// Ambiguity if upvars haven't been constrained yet
419419
&& !args.tupled_upvars_ty().is_ty_var()
420420
{
421-
let no_borrows = match args.tupled_upvars_ty().kind() {
422-
ty::Tuple(tys) => tys.is_empty(),
423-
ty::Error(_) => false,
424-
_ => bug!("tuple_fields called on non-tuple"),
425-
};
426421
// A coroutine-closure implements `FnOnce` *always*, since it may
427422
// always be called once. It additionally implements `Fn`/`FnMut`
428-
// only if it has no upvars (therefore no borrows from the closure
429-
// that would need to be represented with a lifetime) and if the
430-
// closure kind permits it.
431-
// FIXME(async_closures): Actually, it could also implement `Fn`/`FnMut`
432-
// if it takes all of its upvars by copy, and none by ref. This would
433-
// require us to record a bit more information during upvar analysis.
434-
if no_borrows && closure_kind.extends(kind) {
423+
// only if it has no upvars referencing the closure-env lifetime,
424+
// and if the closure kind permits it.
425+
if closure_kind.extends(kind) && !args.has_self_borrows() {
435426
candidates.vec.push(ClosureCandidate { is_const });
436427
} else if kind == ty::ClosureKind::FnOnce {
437428
candidates.vec.push(ClosureCandidate { is_const });

0 commit comments

Comments
 (0)