Skip to content

Commit 62bb2ac

Browse files
borsbors
committed
Auto merge of #132798 - workingjubilee:rollup-qxvmmqo, r=workingjubilee
Rollup of 5 pull requests Successful merges: - #132755 (Do not reveal opaques in the param-env, we got lazy norm instead) - #132757 (Get rid of `check_opaque_type_well_formed`) - #132760 (Don't suggest `.into_iter()` on iterators) - #132778 (update io::Error::into_inner to acknowledge io::Error::other) - #132780 (use verbose for path separator suggestion) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 012ae13 + c4922f1 commit 62bb2ac

File tree

47 files changed

+559
-445
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

47 files changed

+559
-445
lines changed

‎compiler/rustc_borrowck/src/region_infer/opaque_types.rs

+1-89
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,14 @@
11
use rustc_data_structures::fx::FxIndexMap;
22
use rustc_errors::ErrorGuaranteed;
3-
use rustc_hir::OpaqueTyOrigin;
4-
use rustc_hir::def::DefKind;
53
use rustc_hir::def_id::LocalDefId;
64
use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, TyCtxtInferExt as _};
7-
use rustc_infer::traits::{Obligation, ObligationCause};
85
use rustc_macros::extension;
96
use rustc_middle::ty::visit::TypeVisitableExt;
107
use rustc_middle::ty::{
118
self, GenericArgKind, GenericArgs, OpaqueHiddenType, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable,
129
TypingMode,
1310
};
1411
use rustc_span::Span;
15-
use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
1612
use rustc_trait_selection::traits::ObligationCtxt;
1713
use tracing::{debug, instrument};
1814

@@ -303,91 +299,7 @@ impl<'tcx> InferCtxt<'tcx> {
303299
return Ty::new_error(self.tcx, e);
304300
}
305301

306-
// `definition_ty` does not live in of the current inference context,
307-
// so lets make sure that we don't accidentally misuse our current `infcx`.
308-
match check_opaque_type_well_formed(
309-
self.tcx,
310-
self.next_trait_solver(),
311-
opaque_type_key.def_id,
312-
instantiated_ty.span,
313-
definition_ty,
314-
) {
315-
Ok(hidden_ty) => hidden_ty,
316-
Err(guar) => Ty::new_error(self.tcx, guar),
317-
}
318-
}
319-
}
320-
321-
/// This logic duplicates most of `check_opaque_meets_bounds`.
322-
/// FIXME(oli-obk): Also do region checks here and then consider removing
323-
/// `check_opaque_meets_bounds` entirely.
324-
fn check_opaque_type_well_formed<'tcx>(
325-
tcx: TyCtxt<'tcx>,
326-
next_trait_solver: bool,
327-
def_id: LocalDefId,
328-
definition_span: Span,
329-
definition_ty: Ty<'tcx>,
330-
) -> Result<Ty<'tcx>, ErrorGuaranteed> {
331-
// Only check this for TAIT. RPIT already supports `tests/ui/impl-trait/nested-return-type2.rs`
332-
// on stable and we'd break that.
333-
let opaque_ty_hir = tcx.hir().expect_opaque_ty(def_id);
334-
let OpaqueTyOrigin::TyAlias { .. } = opaque_ty_hir.origin else {
335-
return Ok(definition_ty);
336-
};
337-
let param_env = tcx.param_env(def_id);
338-
339-
let mut parent_def_id = def_id;
340-
while tcx.def_kind(parent_def_id) == DefKind::OpaqueTy {
341-
parent_def_id = tcx.local_parent(parent_def_id);
342-
}
343-
344-
// FIXME(#132279): This should eventually use the already defined hidden types
345-
// instead. Alternatively we'll entirely remove this function given we also check
346-
// the opaque in `check_opaque_meets_bounds` later.
347-
let infcx = tcx
348-
.infer_ctxt()
349-
.with_next_trait_solver(next_trait_solver)
350-
.build(TypingMode::analysis_in_body(tcx, parent_def_id));
351-
let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
352-
let identity_args = GenericArgs::identity_for_item(tcx, def_id);
353-
354-
// Require that the hidden type actually fulfills all the bounds of the opaque type, even without
355-
// the bounds that the function supplies.
356-
let opaque_ty = Ty::new_opaque(tcx, def_id.to_def_id(), identity_args);
357-
ocx.eq(&ObligationCause::misc(definition_span, def_id), param_env, opaque_ty, definition_ty)
358-
.map_err(|err| {
359-
infcx
360-
.err_ctxt()
361-
.report_mismatched_types(
362-
&ObligationCause::misc(definition_span, def_id),
363-
param_env,
364-
opaque_ty,
365-
definition_ty,
366-
err,
367-
)
368-
.emit()
369-
})?;
370-
371-
// Require the hidden type to be well-formed with only the generics of the opaque type.
372-
// Defining use functions may have more bounds than the opaque type, which is ok, as long as the
373-
// hidden type is well formed even without those bounds.
374-
let predicate = ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(
375-
definition_ty.into(),
376-
)));
377-
ocx.register_obligation(Obligation::misc(tcx, definition_span, def_id, param_env, predicate));
378-
379-
// Check that all obligations are satisfied by the implementation's
380-
// version.
381-
let errors = ocx.select_all_or_error();
382-
383-
// This is fishy, but we check it again in `check_opaque_meets_bounds`.
384-
// Remove once we can prepopulate with known hidden types.
385-
let _ = infcx.take_opaque_types();
386-
387-
if errors.is_empty() {
388-
Ok(definition_ty)
389-
} else {
390-
Err(infcx.err_ctxt().report_fulfillment_errors(errors))
302+
definition_ty
391303
}
392304
}
393305

‎compiler/rustc_hir_analysis/src/check/check.rs

+136-19
Original file line numberDiff line numberDiff line change
@@ -5,13 +5,14 @@ use rustc_abi::FieldIdx;
55
use rustc_data_structures::unord::{UnordMap, UnordSet};
66
use rustc_errors::MultiSpan;
77
use rustc_errors::codes::*;
8-
use rustc_hir::Node;
98
use rustc_hir::def::{CtorKind, DefKind};
9+
use rustc_hir::{Node, intravisit};
1010
use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
11-
use rustc_infer::traits::Obligation;
11+
use rustc_infer::traits::{Obligation, ObligationCauseCode};
1212
use rustc_lint_defs::builtin::{
1313
REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS, UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS,
1414
};
15+
use rustc_middle::hir::nested_filter;
1516
use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
1617
use rustc_middle::middle::stability::EvalResult;
1718
use rustc_middle::span_bug;
@@ -190,7 +191,7 @@ fn check_static_inhabited(tcx: TyCtxt<'_>, def_id: LocalDefId) {
190191
/// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
191192
/// projections that would result in "inheriting lifetimes".
192193
fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
193-
let hir::OpaqueTy { origin, .. } = tcx.hir().expect_opaque_ty(def_id);
194+
let hir::OpaqueTy { origin, .. } = *tcx.hir().expect_opaque_ty(def_id);
194195

195196
// HACK(jynelson): trying to infer the type of `impl trait` breaks documenting
196197
// `async-std` (and `pub async fn` in general).
@@ -200,23 +201,20 @@ fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
200201
return;
201202
}
202203

203-
let span = tcx.def_span(def_id);
204-
205204
if tcx.type_of(def_id).instantiate_identity().references_error() {
206205
return;
207206
}
208-
if check_opaque_for_cycles(tcx, def_id, span).is_err() {
207+
if check_opaque_for_cycles(tcx, def_id).is_err() {
209208
return;
210209
}
211210

212-
let _ = check_opaque_meets_bounds(tcx, def_id, span, origin);
211+
let _ = check_opaque_meets_bounds(tcx, def_id, origin);
213212
}
214213

215214
/// Checks that an opaque type does not contain cycles.
216215
pub(super) fn check_opaque_for_cycles<'tcx>(
217216
tcx: TyCtxt<'tcx>,
218217
def_id: LocalDefId,
219-
span: Span,
220218
) -> Result<(), ErrorGuaranteed> {
221219
let args = GenericArgs::identity_for_item(tcx, def_id);
222220

@@ -233,7 +231,7 @@ pub(super) fn check_opaque_for_cycles<'tcx>(
233231
.try_expand_impl_trait_type(def_id.to_def_id(), args, InspectCoroutineFields::No)
234232
.is_err()
235233
{
236-
let reported = opaque_type_cycle_error(tcx, def_id, span);
234+
let reported = opaque_type_cycle_error(tcx, def_id);
237235
return Err(reported);
238236
}
239237

@@ -267,10 +265,16 @@ pub(super) fn check_opaque_for_cycles<'tcx>(
267265
fn check_opaque_meets_bounds<'tcx>(
268266
tcx: TyCtxt<'tcx>,
269267
def_id: LocalDefId,
270-
span: Span,
271-
origin: &hir::OpaqueTyOrigin<LocalDefId>,
268+
origin: hir::OpaqueTyOrigin<LocalDefId>,
272269
) -> Result<(), ErrorGuaranteed> {
273-
let defining_use_anchor = match *origin {
270+
let (span, definition_def_id) =
271+
if let Some((span, def_id)) = best_definition_site_of_opaque(tcx, def_id, origin) {
272+
(span, Some(def_id))
273+
} else {
274+
(tcx.def_span(def_id), None)
275+
};
276+
277+
let defining_use_anchor = match origin {
274278
hir::OpaqueTyOrigin::FnReturn { parent, .. }
275279
| hir::OpaqueTyOrigin::AsyncFn { parent, .. }
276280
| hir::OpaqueTyOrigin::TyAlias { parent, .. } => parent,
@@ -281,7 +285,7 @@ fn check_opaque_meets_bounds<'tcx>(
281285
let infcx = tcx.infer_ctxt().build(TypingMode::analysis_in_body(tcx, defining_use_anchor));
282286
let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
283287

284-
let args = match *origin {
288+
let args = match origin {
285289
hir::OpaqueTyOrigin::FnReturn { parent, .. }
286290
| hir::OpaqueTyOrigin::AsyncFn { parent, .. }
287291
| hir::OpaqueTyOrigin::TyAlias { parent, .. } => GenericArgs::identity_for_item(
@@ -306,8 +310,33 @@ fn check_opaque_meets_bounds<'tcx>(
306310
_ => re,
307311
});
308312

309-
let misc_cause = traits::ObligationCause::misc(span, def_id);
313+
// HACK: We eagerly instantiate some bounds to report better errors for them...
314+
// This isn't necessary for correctness, since we register these bounds when
315+
// equating the opaque below, but we should clean this up in the new solver.
316+
for (predicate, pred_span) in
317+
tcx.explicit_item_bounds(def_id).iter_instantiated_copied(tcx, args)
318+
{
319+
let predicate = predicate.fold_with(&mut BottomUpFolder {
320+
tcx,
321+
ty_op: |ty| if ty == opaque_ty { hidden_ty } else { ty },
322+
lt_op: |lt| lt,
323+
ct_op: |ct| ct,
324+
});
325+
326+
ocx.register_obligation(Obligation::new(
327+
tcx,
328+
ObligationCause::new(
329+
span,
330+
def_id,
331+
ObligationCauseCode::OpaqueTypeBound(pred_span, definition_def_id),
332+
),
333+
param_env,
334+
predicate,
335+
));
336+
}
310337

338+
let misc_cause = ObligationCause::misc(span, def_id);
339+
// FIXME: We should just register the item bounds here, rather than equating.
311340
match ocx.eq(&misc_cause, param_env, opaque_ty, hidden_ty) {
312341
Ok(()) => {}
313342
Err(ty_err) => {
@@ -364,6 +393,97 @@ fn check_opaque_meets_bounds<'tcx>(
364393
}
365394
}
366395

396+
fn best_definition_site_of_opaque<'tcx>(
397+
tcx: TyCtxt<'tcx>,
398+
opaque_def_id: LocalDefId,
399+
origin: hir::OpaqueTyOrigin<LocalDefId>,
400+
) -> Option<(Span, LocalDefId)> {
401+
struct TaitConstraintLocator<'tcx> {
402+
opaque_def_id: LocalDefId,
403+
tcx: TyCtxt<'tcx>,
404+
}
405+
impl<'tcx> TaitConstraintLocator<'tcx> {
406+
fn check(&self, item_def_id: LocalDefId) -> ControlFlow<(Span, LocalDefId)> {
407+
if !self.tcx.has_typeck_results(item_def_id) {
408+
return ControlFlow::Continue(());
409+
}
410+
411+
if let Some(hidden_ty) =
412+
self.tcx.mir_borrowck(item_def_id).concrete_opaque_types.get(&self.opaque_def_id)
413+
{
414+
ControlFlow::Break((hidden_ty.span, item_def_id))
415+
} else {
416+
ControlFlow::Continue(())
417+
}
418+
}
419+
}
420+
impl<'tcx> intravisit::Visitor<'tcx> for TaitConstraintLocator<'tcx> {
421+
type NestedFilter = nested_filter::All;
422+
type Result = ControlFlow<(Span, LocalDefId)>;
423+
fn nested_visit_map(&mut self) -> Self::Map {
424+
self.tcx.hir()
425+
}
426+
fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) -> Self::Result {
427+
if let hir::ExprKind::Closure(closure) = ex.kind {
428+
self.check(closure.def_id)?;
429+
}
430+
intravisit::walk_expr(self, ex)
431+
}
432+
fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) -> Self::Result {
433+
self.check(it.owner_id.def_id)?;
434+
intravisit::walk_item(self, it)
435+
}
436+
fn visit_impl_item(&mut self, it: &'tcx hir::ImplItem<'tcx>) -> Self::Result {
437+
self.check(it.owner_id.def_id)?;
438+
intravisit::walk_impl_item(self, it)
439+
}
440+
fn visit_trait_item(&mut self, it: &'tcx hir::TraitItem<'tcx>) -> Self::Result {
441+
self.check(it.owner_id.def_id)?;
442+
intravisit::walk_trait_item(self, it)
443+
}
444+
fn visit_foreign_item(&mut self, it: &'tcx hir::ForeignItem<'tcx>) -> Self::Result {
445+
intravisit::walk_foreign_item(self, it)
446+
}
447+
}
448+
449+
let mut locator = TaitConstraintLocator { tcx, opaque_def_id };
450+
match origin {
451+
hir::OpaqueTyOrigin::FnReturn { parent, .. }
452+
| hir::OpaqueTyOrigin::AsyncFn { parent, .. } => locator.check(parent).break_value(),
453+
hir::OpaqueTyOrigin::TyAlias { parent, in_assoc_ty: true } => {
454+
let impl_def_id = tcx.local_parent(parent);
455+
for assoc in tcx.associated_items(impl_def_id).in_definition_order() {
456+
match assoc.kind {
457+
ty::AssocKind::Const | ty::AssocKind::Fn => {
458+
if let ControlFlow::Break(span) = locator.check(assoc.def_id.expect_local())
459+
{
460+
return Some(span);
461+
}
462+
}
463+
ty::AssocKind::Type => {}
464+
}
465+
}
466+
467+
None
468+
}
469+
hir::OpaqueTyOrigin::TyAlias { in_assoc_ty: false, .. } => {
470+
let scope = tcx.hir().get_defining_scope(tcx.local_def_id_to_hir_id(opaque_def_id));
471+
let found = if scope == hir::CRATE_HIR_ID {
472+
tcx.hir().walk_toplevel_module(&mut locator)
473+
} else {
474+
match tcx.hir_node(scope) {
475+
Node::Item(it) => locator.visit_item(it),
476+
Node::ImplItem(it) => locator.visit_impl_item(it),
477+
Node::TraitItem(it) => locator.visit_trait_item(it),
478+
Node::ForeignItem(it) => locator.visit_foreign_item(it),
479+
other => bug!("{:?} is not a valid scope for an opaque type item", other),
480+
}
481+
};
482+
found.break_value()
483+
}
484+
}
485+
}
486+
367487
fn sanity_check_found_hidden_type<'tcx>(
368488
tcx: TyCtxt<'tcx>,
369489
key: ty::OpaqueTypeKey<'tcx>,
@@ -1535,11 +1655,8 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
15351655
///
15361656
/// If all the return expressions evaluate to `!`, then we explain that the error will go away
15371657
/// after changing it. This can happen when a user uses `panic!()` or similar as a placeholder.
1538-
fn opaque_type_cycle_error(
1539-
tcx: TyCtxt<'_>,
1540-
opaque_def_id: LocalDefId,
1541-
span: Span,
1542-
) -> ErrorGuaranteed {
1658+
fn opaque_type_cycle_error(tcx: TyCtxt<'_>, opaque_def_id: LocalDefId) -> ErrorGuaranteed {
1659+
let span = tcx.def_span(opaque_def_id);
15431660
let mut err = struct_span_code_err!(tcx.dcx(), span, E0720, "cannot resolve opaque type");
15441661

15451662
let mut label = false;

0 commit comments

Comments
 (0)