rustc_hir_analysis/check/
check.rs

1use std::cell::LazyCell;
2use std::ops::ControlFlow;
3
4use rustc_abi::{ExternAbi, FieldIdx};
5use rustc_attr_data_structures::ReprAttr::ReprPacked;
6use rustc_attr_data_structures::{AttributeKind, find_attr};
7use rustc_data_structures::unord::{UnordMap, UnordSet};
8use rustc_errors::codes::*;
9use rustc_errors::{EmissionGuarantee, MultiSpan};
10use rustc_hir::def::{CtorKind, DefKind};
11use rustc_hir::{LangItem, Node, intravisit};
12use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
13use rustc_infer::traits::{Obligation, ObligationCauseCode, WellFormedLoc};
14use rustc_lint_defs::builtin::{
15    REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS, UNSUPPORTED_CALLING_CONVENTIONS,
16};
17use rustc_middle::hir::nested_filter;
18use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
19use rustc_middle::middle::stability::EvalResult;
20use rustc_middle::ty::error::TypeErrorToStringExt;
21use rustc_middle::ty::layout::{LayoutError, MAX_SIMD_LANES};
22use rustc_middle::ty::util::Discr;
23use rustc_middle::ty::{
24    AdtDef, BottomUpFolder, FnSig, GenericArgKind, RegionKind, TypeFoldable, TypeSuperVisitable,
25    TypeVisitable, TypeVisitableExt, fold_regions,
26};
27use rustc_session::lint::builtin::UNINHABITED_STATIC;
28use rustc_target::spec::{AbiMap, AbiMapping};
29use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
30use rustc_trait_selection::error_reporting::traits::on_unimplemented::OnUnimplementedDirective;
31use rustc_trait_selection::traits;
32use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
33use tracing::{debug, instrument};
34use ty::TypingMode;
35use {rustc_attr_data_structures as attrs, rustc_hir as hir};
36
37use super::compare_impl_item::check_type_bounds;
38use super::*;
39use crate::check::wfcheck::{
40    check_associated_item, check_trait_item, check_variances_for_type_defn, check_where_clauses,
41    enter_wf_checking_ctxt,
42};
43
44fn add_abi_diag_help<T: EmissionGuarantee>(abi: ExternAbi, diag: &mut Diag<'_, T>) {
45    if let ExternAbi::Cdecl { unwind } = abi {
46        let c_abi = ExternAbi::C { unwind };
47        diag.help(format!("use `extern {c_abi}` instead",));
48    } else if let ExternAbi::Stdcall { unwind } = abi {
49        let c_abi = ExternAbi::C { unwind };
50        let system_abi = ExternAbi::System { unwind };
51        diag.help(format!(
52            "if you need `extern {abi}` on win32 and `extern {c_abi}` everywhere else, \
53                use `extern {system_abi}`"
54        ));
55    }
56}
57
58pub fn check_abi(tcx: TyCtxt<'_>, hir_id: hir::HirId, span: Span, abi: ExternAbi) {
59    // FIXME: This should be checked earlier, e.g. in `rustc_ast_lowering`, as this
60    // currently only guards function imports, function definitions, and function pointer types.
61    // Functions in trait declarations can still use "deprecated" ABIs without any warning.
62
63    match AbiMap::from_target(&tcx.sess.target).canonize_abi(abi, false) {
64        AbiMapping::Direct(..) => (),
65        // already erred in rustc_ast_lowering
66        AbiMapping::Invalid => {
67            tcx.dcx().span_delayed_bug(span, format!("{abi} should be rejected in ast_lowering"));
68        }
69        AbiMapping::Deprecated(..) => {
70            tcx.node_span_lint(UNSUPPORTED_CALLING_CONVENTIONS, hir_id, span, |lint| {
71                lint.primary_message(format!(
72                    "{abi} is not a supported ABI for the current target"
73                ));
74                add_abi_diag_help(abi, lint);
75            });
76        }
77    }
78}
79
80pub fn check_custom_abi(tcx: TyCtxt<'_>, def_id: LocalDefId, fn_sig: FnSig<'_>, fn_sig_span: Span) {
81    if fn_sig.abi == ExternAbi::Custom {
82        // Function definitions that use `extern "custom"` must be naked functions.
83        if !find_attr!(tcx.get_all_attrs(def_id), AttributeKind::Naked(_)) {
84            tcx.dcx().emit_err(crate::errors::AbiCustomClothedFunction {
85                span: fn_sig_span,
86                naked_span: tcx.def_span(def_id).shrink_to_lo(),
87            });
88        }
89    }
90}
91
92fn check_struct(tcx: TyCtxt<'_>, def_id: LocalDefId) {
93    let def = tcx.adt_def(def_id);
94    let span = tcx.def_span(def_id);
95    def.destructor(tcx); // force the destructor to be evaluated
96
97    if def.repr().simd() {
98        check_simd(tcx, span, def_id);
99    }
100
101    check_transparent(tcx, def);
102    check_packed(tcx, span, def);
103}
104
105fn check_union(tcx: TyCtxt<'_>, def_id: LocalDefId) {
106    let def = tcx.adt_def(def_id);
107    let span = tcx.def_span(def_id);
108    def.destructor(tcx); // force the destructor to be evaluated
109    check_transparent(tcx, def);
110    check_union_fields(tcx, span, def_id);
111    check_packed(tcx, span, def);
112}
113
114fn allowed_union_or_unsafe_field<'tcx>(
115    tcx: TyCtxt<'tcx>,
116    ty: Ty<'tcx>,
117    typing_env: ty::TypingEnv<'tcx>,
118    span: Span,
119) -> bool {
120    // HACK (not that bad of a hack don't worry): Some codegen tests don't even define proper
121    // impls for `Copy`. Let's short-circuit here for this validity check, since a lot of them
122    // use unions. We should eventually fix all the tests to define that lang item or use
123    // minicore stubs.
124    if ty.is_trivially_pure_clone_copy() {
125        return true;
126    }
127    // If `BikeshedGuaranteedNoDrop` is not defined in a `#[no_core]` test, fall back to `Copy`.
128    // This is an underapproximation of `BikeshedGuaranteedNoDrop`,
129    let def_id = tcx
130        .lang_items()
131        .get(LangItem::BikeshedGuaranteedNoDrop)
132        .unwrap_or_else(|| tcx.require_lang_item(LangItem::Copy, span));
133    let Ok(ty) = tcx.try_normalize_erasing_regions(typing_env, ty) else {
134        tcx.dcx().span_delayed_bug(span, "could not normalize field type");
135        return true;
136    };
137    let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(typing_env);
138    infcx.predicate_must_hold_modulo_regions(&Obligation::new(
139        tcx,
140        ObligationCause::dummy_with_span(span),
141        param_env,
142        ty::TraitRef::new(tcx, def_id, [ty]),
143    ))
144}
145
146/// Check that the fields of the `union` do not need dropping.
147fn check_union_fields(tcx: TyCtxt<'_>, span: Span, item_def_id: LocalDefId) -> bool {
148    let def = tcx.adt_def(item_def_id);
149    assert!(def.is_union());
150
151    let typing_env = ty::TypingEnv::non_body_analysis(tcx, item_def_id);
152    let args = ty::GenericArgs::identity_for_item(tcx, item_def_id);
153
154    for field in &def.non_enum_variant().fields {
155        if !allowed_union_or_unsafe_field(tcx, field.ty(tcx, args), typing_env, span) {
156            let (field_span, ty_span) = match tcx.hir_get_if_local(field.did) {
157                // We are currently checking the type this field came from, so it must be local.
158                Some(Node::Field(field)) => (field.span, field.ty.span),
159                _ => unreachable!("mir field has to correspond to hir field"),
160            };
161            tcx.dcx().emit_err(errors::InvalidUnionField {
162                field_span,
163                sugg: errors::InvalidUnionFieldSuggestion {
164                    lo: ty_span.shrink_to_lo(),
165                    hi: ty_span.shrink_to_hi(),
166                },
167                note: (),
168            });
169            return false;
170        }
171    }
172
173    true
174}
175
176/// Check that a `static` is inhabited.
177fn check_static_inhabited(tcx: TyCtxt<'_>, def_id: LocalDefId) {
178    // Make sure statics are inhabited.
179    // Other parts of the compiler assume that there are no uninhabited places. In principle it
180    // would be enough to check this for `extern` statics, as statics with an initializer will
181    // have UB during initialization if they are uninhabited, but there also seems to be no good
182    // reason to allow any statics to be uninhabited.
183    let ty = tcx.type_of(def_id).instantiate_identity();
184    let span = tcx.def_span(def_id);
185    let layout = match tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty)) {
186        Ok(l) => l,
187        // Foreign statics that overflow their allowed size should emit an error
188        Err(LayoutError::SizeOverflow(_))
189            if matches!(tcx.def_kind(def_id), DefKind::Static{ .. }
190                if tcx.def_kind(tcx.local_parent(def_id)) == DefKind::ForeignMod) =>
191        {
192            tcx.dcx().emit_err(errors::TooLargeStatic { span });
193            return;
194        }
195        // Generic statics are rejected, but we still reach this case.
196        Err(e) => {
197            tcx.dcx().span_delayed_bug(span, format!("{e:?}"));
198            return;
199        }
200    };
201    if layout.is_uninhabited() {
202        tcx.node_span_lint(
203            UNINHABITED_STATIC,
204            tcx.local_def_id_to_hir_id(def_id),
205            span,
206            |lint| {
207                lint.primary_message("static of uninhabited type");
208                lint
209                .note("uninhabited statics cannot be initialized, and any access would be an immediate error");
210            },
211        );
212    }
213}
214
215/// Checks that an opaque type does not contain cycles and does not use `Self` or `T::Foo`
216/// projections that would result in "inheriting lifetimes".
217fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
218    let hir::OpaqueTy { origin, .. } = *tcx.hir_expect_opaque_ty(def_id);
219
220    // HACK(jynelson): trying to infer the type of `impl trait` breaks documenting
221    // `async-std` (and `pub async fn` in general).
222    // Since rustdoc doesn't care about the concrete type behind `impl Trait`, just don't look at it!
223    // See https://github.com/rust-lang/rust/issues/75100
224    if tcx.sess.opts.actually_rustdoc {
225        return;
226    }
227
228    if tcx.type_of(def_id).instantiate_identity().references_error() {
229        return;
230    }
231    if check_opaque_for_cycles(tcx, def_id).is_err() {
232        return;
233    }
234
235    let _ = check_opaque_meets_bounds(tcx, def_id, origin);
236}
237
238/// Checks that an opaque type does not contain cycles.
239pub(super) fn check_opaque_for_cycles<'tcx>(
240    tcx: TyCtxt<'tcx>,
241    def_id: LocalDefId,
242) -> Result<(), ErrorGuaranteed> {
243    let args = GenericArgs::identity_for_item(tcx, def_id);
244
245    // First, try to look at any opaque expansion cycles, considering coroutine fields
246    // (even though these aren't necessarily true errors).
247    if tcx.try_expand_impl_trait_type(def_id.to_def_id(), args).is_err() {
248        let reported = opaque_type_cycle_error(tcx, def_id);
249        return Err(reported);
250    }
251
252    Ok(())
253}
254
255/// Check that the concrete type behind `impl Trait` actually implements `Trait`.
256///
257/// This is mostly checked at the places that specify the opaque type, but we
258/// check those cases in the `param_env` of that function, which may have
259/// bounds not on this opaque type:
260///
261/// ```ignore (illustrative)
262/// type X<T> = impl Clone;
263/// fn f<T: Clone>(t: T) -> X<T> {
264///     t
265/// }
266/// ```
267///
268/// Without this check the above code is incorrectly accepted: we would ICE if
269/// some tried, for example, to clone an `Option<X<&mut ()>>`.
270#[instrument(level = "debug", skip(tcx))]
271fn check_opaque_meets_bounds<'tcx>(
272    tcx: TyCtxt<'tcx>,
273    def_id: LocalDefId,
274    origin: hir::OpaqueTyOrigin<LocalDefId>,
275) -> Result<(), ErrorGuaranteed> {
276    let (span, definition_def_id) =
277        if let Some((span, def_id)) = best_definition_site_of_opaque(tcx, def_id, origin) {
278            (span, Some(def_id))
279        } else {
280            (tcx.def_span(def_id), None)
281        };
282
283    let defining_use_anchor = match origin {
284        hir::OpaqueTyOrigin::FnReturn { parent, .. }
285        | hir::OpaqueTyOrigin::AsyncFn { parent, .. }
286        | hir::OpaqueTyOrigin::TyAlias { parent, .. } => parent,
287    };
288    let param_env = tcx.param_env(defining_use_anchor);
289
290    // FIXME(#132279): Once `PostBorrowckAnalysis` is supported in the old solver, this branch should be removed.
291    let infcx = tcx.infer_ctxt().build(if tcx.next_trait_solver_globally() {
292        TypingMode::post_borrowck_analysis(tcx, defining_use_anchor)
293    } else {
294        TypingMode::analysis_in_body(tcx, defining_use_anchor)
295    });
296    let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
297
298    let args = match origin {
299        hir::OpaqueTyOrigin::FnReturn { parent, .. }
300        | hir::OpaqueTyOrigin::AsyncFn { parent, .. }
301        | hir::OpaqueTyOrigin::TyAlias { parent, .. } => GenericArgs::identity_for_item(
302            tcx, parent,
303        )
304        .extend_to(tcx, def_id.to_def_id(), |param, _| {
305            tcx.map_opaque_lifetime_to_parent_lifetime(param.def_id.expect_local()).into()
306        }),
307    };
308
309    let opaque_ty = Ty::new_opaque(tcx, def_id.to_def_id(), args);
310
311    // `ReErased` regions appear in the "parent_args" of closures/coroutines.
312    // We're ignoring them here and replacing them with fresh region variables.
313    // See tests in ui/type-alias-impl-trait/closure_{parent_args,wf_outlives}.rs.
314    //
315    // FIXME: Consider wrapping the hidden type in an existential `Binder` and instantiating it
316    // here rather than using ReErased.
317    let hidden_ty = tcx.type_of(def_id.to_def_id()).instantiate(tcx, args);
318    let hidden_ty = fold_regions(tcx, hidden_ty, |re, _dbi| match re.kind() {
319        ty::ReErased => infcx.next_region_var(RegionVariableOrigin::Misc(span)),
320        _ => re,
321    });
322
323    // HACK: We eagerly instantiate some bounds to report better errors for them...
324    // This isn't necessary for correctness, since we register these bounds when
325    // equating the opaque below, but we should clean this up in the new solver.
326    for (predicate, pred_span) in
327        tcx.explicit_item_bounds(def_id).iter_instantiated_copied(tcx, args)
328    {
329        let predicate = predicate.fold_with(&mut BottomUpFolder {
330            tcx,
331            ty_op: |ty| if ty == opaque_ty { hidden_ty } else { ty },
332            lt_op: |lt| lt,
333            ct_op: |ct| ct,
334        });
335
336        ocx.register_obligation(Obligation::new(
337            tcx,
338            ObligationCause::new(
339                span,
340                def_id,
341                ObligationCauseCode::OpaqueTypeBound(pred_span, definition_def_id),
342            ),
343            param_env,
344            predicate,
345        ));
346    }
347
348    let misc_cause = ObligationCause::misc(span, def_id);
349    // FIXME: We should just register the item bounds here, rather than equating.
350    // FIXME(const_trait_impl): When we do that, please make sure to also register
351    // the `[const]` bounds.
352    match ocx.eq(&misc_cause, param_env, opaque_ty, hidden_ty) {
353        Ok(()) => {}
354        Err(ty_err) => {
355            // Some types may be left "stranded" if they can't be reached
356            // from a lowered rustc_middle bound but they're mentioned in the HIR.
357            // This will happen, e.g., when a nested opaque is inside of a non-
358            // existent associated type, like `impl Trait<Missing = impl Trait>`.
359            // See <tests/ui/impl-trait/stranded-opaque.rs>.
360            let ty_err = ty_err.to_string(tcx);
361            let guar = tcx.dcx().span_delayed_bug(
362                span,
363                format!("could not unify `{hidden_ty}` with revealed type:\n{ty_err}"),
364            );
365            return Err(guar);
366        }
367    }
368
369    // Additionally require the hidden type to be well-formed with only the generics of the opaque type.
370    // Defining use functions may have more bounds than the opaque type, which is ok, as long as the
371    // hidden type is well formed even without those bounds.
372    let predicate =
373        ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(hidden_ty.into())));
374    ocx.register_obligation(Obligation::new(tcx, misc_cause.clone(), param_env, predicate));
375
376    // Check that all obligations are satisfied by the implementation's
377    // version.
378    let errors = ocx.select_all_or_error();
379    if !errors.is_empty() {
380        let guar = infcx.err_ctxt().report_fulfillment_errors(errors);
381        return Err(guar);
382    }
383
384    let wf_tys = ocx.assumed_wf_types_and_report_errors(param_env, defining_use_anchor)?;
385    ocx.resolve_regions_and_report_errors(defining_use_anchor, param_env, wf_tys)?;
386
387    if infcx.next_trait_solver() {
388        Ok(())
389    } else if let hir::OpaqueTyOrigin::FnReturn { .. } | hir::OpaqueTyOrigin::AsyncFn { .. } =
390        origin
391    {
392        // HACK: this should also fall through to the hidden type check below, but the original
393        // implementation had a bug where equivalent lifetimes are not identical. This caused us
394        // to reject existing stable code that is otherwise completely fine. The real fix is to
395        // compare the hidden types via our type equivalence/relation infra instead of doing an
396        // identity check.
397        let _ = infcx.take_opaque_types();
398        Ok(())
399    } else {
400        // Check that any hidden types found during wf checking match the hidden types that `type_of` sees.
401        for (mut key, mut ty) in infcx.take_opaque_types() {
402            ty.ty = infcx.resolve_vars_if_possible(ty.ty);
403            key = infcx.resolve_vars_if_possible(key);
404            sanity_check_found_hidden_type(tcx, key, ty)?;
405        }
406        Ok(())
407    }
408}
409
410fn best_definition_site_of_opaque<'tcx>(
411    tcx: TyCtxt<'tcx>,
412    opaque_def_id: LocalDefId,
413    origin: hir::OpaqueTyOrigin<LocalDefId>,
414) -> Option<(Span, LocalDefId)> {
415    struct TaitConstraintLocator<'tcx> {
416        opaque_def_id: LocalDefId,
417        tcx: TyCtxt<'tcx>,
418    }
419    impl<'tcx> TaitConstraintLocator<'tcx> {
420        fn check(&self, item_def_id: LocalDefId) -> ControlFlow<(Span, LocalDefId)> {
421            if !self.tcx.has_typeck_results(item_def_id) {
422                return ControlFlow::Continue(());
423            }
424
425            let opaque_types_defined_by = self.tcx.opaque_types_defined_by(item_def_id);
426            // Don't try to check items that cannot possibly constrain the type.
427            if !opaque_types_defined_by.contains(&self.opaque_def_id) {
428                return ControlFlow::Continue(());
429            }
430
431            if let Some(hidden_ty) = self
432                .tcx
433                .mir_borrowck(item_def_id)
434                .ok()
435                .and_then(|opaque_types| opaque_types.0.get(&self.opaque_def_id))
436            {
437                ControlFlow::Break((hidden_ty.span, item_def_id))
438            } else {
439                ControlFlow::Continue(())
440            }
441        }
442    }
443    impl<'tcx> intravisit::Visitor<'tcx> for TaitConstraintLocator<'tcx> {
444        type NestedFilter = nested_filter::All;
445        type Result = ControlFlow<(Span, LocalDefId)>;
446        fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
447            self.tcx
448        }
449        fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) -> Self::Result {
450            intravisit::walk_expr(self, ex)
451        }
452        fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) -> Self::Result {
453            self.check(it.owner_id.def_id)?;
454            intravisit::walk_item(self, it)
455        }
456        fn visit_impl_item(&mut self, it: &'tcx hir::ImplItem<'tcx>) -> Self::Result {
457            self.check(it.owner_id.def_id)?;
458            intravisit::walk_impl_item(self, it)
459        }
460        fn visit_trait_item(&mut self, it: &'tcx hir::TraitItem<'tcx>) -> Self::Result {
461            self.check(it.owner_id.def_id)?;
462            intravisit::walk_trait_item(self, it)
463        }
464        fn visit_foreign_item(&mut self, it: &'tcx hir::ForeignItem<'tcx>) -> Self::Result {
465            intravisit::walk_foreign_item(self, it)
466        }
467    }
468
469    let mut locator = TaitConstraintLocator { tcx, opaque_def_id };
470    match origin {
471        hir::OpaqueTyOrigin::FnReturn { parent, .. }
472        | hir::OpaqueTyOrigin::AsyncFn { parent, .. } => locator.check(parent).break_value(),
473        hir::OpaqueTyOrigin::TyAlias { parent, in_assoc_ty: true } => {
474            let impl_def_id = tcx.local_parent(parent);
475            for assoc in tcx.associated_items(impl_def_id).in_definition_order() {
476                match assoc.kind {
477                    ty::AssocKind::Const { .. } | ty::AssocKind::Fn { .. } => {
478                        if let ControlFlow::Break(span) = locator.check(assoc.def_id.expect_local())
479                        {
480                            return Some(span);
481                        }
482                    }
483                    ty::AssocKind::Type { .. } => {}
484                }
485            }
486
487            None
488        }
489        hir::OpaqueTyOrigin::TyAlias { in_assoc_ty: false, .. } => {
490            tcx.hir_walk_toplevel_module(&mut locator).break_value()
491        }
492    }
493}
494
495fn sanity_check_found_hidden_type<'tcx>(
496    tcx: TyCtxt<'tcx>,
497    key: ty::OpaqueTypeKey<'tcx>,
498    mut ty: ty::OpaqueHiddenType<'tcx>,
499) -> Result<(), ErrorGuaranteed> {
500    if ty.ty.is_ty_var() {
501        // Nothing was actually constrained.
502        return Ok(());
503    }
504    if let ty::Alias(ty::Opaque, alias) = ty.ty.kind() {
505        if alias.def_id == key.def_id.to_def_id() && alias.args == key.args {
506            // Nothing was actually constrained, this is an opaque usage that was
507            // only discovered to be opaque after inference vars resolved.
508            return Ok(());
509        }
510    }
511    let strip_vars = |ty: Ty<'tcx>| {
512        ty.fold_with(&mut BottomUpFolder {
513            tcx,
514            ty_op: |t| t,
515            ct_op: |c| c,
516            lt_op: |l| match l.kind() {
517                RegionKind::ReVar(_) => tcx.lifetimes.re_erased,
518                _ => l,
519            },
520        })
521    };
522    // Closures frequently end up containing erased lifetimes in their final representation.
523    // These correspond to lifetime variables that never got resolved, so we patch this up here.
524    ty.ty = strip_vars(ty.ty);
525    // Get the hidden type.
526    let hidden_ty = tcx.type_of(key.def_id).instantiate(tcx, key.args);
527    let hidden_ty = strip_vars(hidden_ty);
528
529    // If the hidden types differ, emit a type mismatch diagnostic.
530    if hidden_ty == ty.ty {
531        Ok(())
532    } else {
533        let span = tcx.def_span(key.def_id);
534        let other = ty::OpaqueHiddenType { ty: hidden_ty, span };
535        Err(ty.build_mismatch_error(&other, tcx)?.emit())
536    }
537}
538
539/// Check that the opaque's precise captures list is valid (if present).
540/// We check this for regular `impl Trait`s and also RPITITs, even though the latter
541/// are technically GATs.
542///
543/// This function is responsible for:
544/// 1. Checking that all type/const params are mention in the captures list.
545/// 2. Checking that all lifetimes that are implicitly captured are mentioned.
546/// 3. Asserting that all parameters mentioned in the captures list are invariant.
547fn check_opaque_precise_captures<'tcx>(tcx: TyCtxt<'tcx>, opaque_def_id: LocalDefId) {
548    let hir::OpaqueTy { bounds, .. } = *tcx.hir_node_by_def_id(opaque_def_id).expect_opaque_ty();
549    let Some(precise_capturing_args) = bounds.iter().find_map(|bound| match *bound {
550        hir::GenericBound::Use(bounds, ..) => Some(bounds),
551        _ => None,
552    }) else {
553        // No precise capturing args; nothing to validate
554        return;
555    };
556
557    let mut expected_captures = UnordSet::default();
558    let mut shadowed_captures = UnordSet::default();
559    let mut seen_params = UnordMap::default();
560    let mut prev_non_lifetime_param = None;
561    for arg in precise_capturing_args {
562        let (hir_id, ident) = match *arg {
563            hir::PreciseCapturingArg::Param(hir::PreciseCapturingNonLifetimeArg {
564                hir_id,
565                ident,
566                ..
567            }) => {
568                if prev_non_lifetime_param.is_none() {
569                    prev_non_lifetime_param = Some(ident);
570                }
571                (hir_id, ident)
572            }
573            hir::PreciseCapturingArg::Lifetime(&hir::Lifetime { hir_id, ident, .. }) => {
574                if let Some(prev_non_lifetime_param) = prev_non_lifetime_param {
575                    tcx.dcx().emit_err(errors::LifetimesMustBeFirst {
576                        lifetime_span: ident.span,
577                        name: ident.name,
578                        other_span: prev_non_lifetime_param.span,
579                    });
580                }
581                (hir_id, ident)
582            }
583        };
584
585        let ident = ident.normalize_to_macros_2_0();
586        if let Some(span) = seen_params.insert(ident, ident.span) {
587            tcx.dcx().emit_err(errors::DuplicatePreciseCapture {
588                name: ident.name,
589                first_span: span,
590                second_span: ident.span,
591            });
592        }
593
594        match tcx.named_bound_var(hir_id) {
595            Some(ResolvedArg::EarlyBound(def_id)) => {
596                expected_captures.insert(def_id.to_def_id());
597
598                // Make sure we allow capturing these lifetimes through `Self` and
599                // `T::Assoc` projection syntax, too. These will occur when we only
600                // see lifetimes are captured after hir-lowering -- this aligns with
601                // the cases that were stabilized with the `impl_trait_projection`
602                // feature -- see <https://github.com/rust-lang/rust/pull/115659>.
603                if let DefKind::LifetimeParam = tcx.def_kind(def_id)
604                    && let Some(def_id) = tcx
605                        .map_opaque_lifetime_to_parent_lifetime(def_id)
606                        .opt_param_def_id(tcx, tcx.parent(opaque_def_id.to_def_id()))
607                {
608                    shadowed_captures.insert(def_id);
609                }
610            }
611            _ => {
612                tcx.dcx()
613                    .span_delayed_bug(tcx.hir_span(hir_id), "parameter should have been resolved");
614            }
615        }
616    }
617
618    let variances = tcx.variances_of(opaque_def_id);
619    let mut def_id = Some(opaque_def_id.to_def_id());
620    while let Some(generics) = def_id {
621        let generics = tcx.generics_of(generics);
622        def_id = generics.parent;
623
624        for param in &generics.own_params {
625            if expected_captures.contains(&param.def_id) {
626                assert_eq!(
627                    variances[param.index as usize],
628                    ty::Invariant,
629                    "precise captured param should be invariant"
630                );
631                continue;
632            }
633            // If a param is shadowed by a early-bound (duplicated) lifetime, then
634            // it may or may not be captured as invariant, depending on if it shows
635            // up through `Self` or `T::Assoc` syntax.
636            if shadowed_captures.contains(&param.def_id) {
637                continue;
638            }
639
640            match param.kind {
641                ty::GenericParamDefKind::Lifetime => {
642                    let use_span = tcx.def_span(param.def_id);
643                    let opaque_span = tcx.def_span(opaque_def_id);
644                    // Check if the lifetime param was captured but isn't named in the precise captures list.
645                    if variances[param.index as usize] == ty::Invariant {
646                        if let DefKind::OpaqueTy = tcx.def_kind(tcx.parent(param.def_id))
647                            && let Some(def_id) = tcx
648                                .map_opaque_lifetime_to_parent_lifetime(param.def_id.expect_local())
649                                .opt_param_def_id(tcx, tcx.parent(opaque_def_id.to_def_id()))
650                        {
651                            tcx.dcx().emit_err(errors::LifetimeNotCaptured {
652                                opaque_span,
653                                use_span,
654                                param_span: tcx.def_span(def_id),
655                            });
656                        } else {
657                            if tcx.def_kind(tcx.parent(param.def_id)) == DefKind::Trait {
658                                tcx.dcx().emit_err(errors::LifetimeImplicitlyCaptured {
659                                    opaque_span,
660                                    param_span: tcx.def_span(param.def_id),
661                                });
662                            } else {
663                                // If the `use_span` is actually just the param itself, then we must
664                                // have not duplicated the lifetime but captured the original.
665                                // The "effective" `use_span` will be the span of the opaque itself,
666                                // and the param span will be the def span of the param.
667                                tcx.dcx().emit_err(errors::LifetimeNotCaptured {
668                                    opaque_span,
669                                    use_span: opaque_span,
670                                    param_span: use_span,
671                                });
672                            }
673                        }
674                        continue;
675                    }
676                }
677                ty::GenericParamDefKind::Type { .. } => {
678                    if matches!(tcx.def_kind(param.def_id), DefKind::Trait | DefKind::TraitAlias) {
679                        // FIXME(precise_capturing): Structured suggestion for this would be useful
680                        tcx.dcx().emit_err(errors::SelfTyNotCaptured {
681                            trait_span: tcx.def_span(param.def_id),
682                            opaque_span: tcx.def_span(opaque_def_id),
683                        });
684                    } else {
685                        // FIXME(precise_capturing): Structured suggestion for this would be useful
686                        tcx.dcx().emit_err(errors::ParamNotCaptured {
687                            param_span: tcx.def_span(param.def_id),
688                            opaque_span: tcx.def_span(opaque_def_id),
689                            kind: "type",
690                        });
691                    }
692                }
693                ty::GenericParamDefKind::Const { .. } => {
694                    // FIXME(precise_capturing): Structured suggestion for this would be useful
695                    tcx.dcx().emit_err(errors::ParamNotCaptured {
696                        param_span: tcx.def_span(param.def_id),
697                        opaque_span: tcx.def_span(opaque_def_id),
698                        kind: "const",
699                    });
700                }
701            }
702        }
703    }
704}
705
706fn is_enum_of_nonnullable_ptr<'tcx>(
707    tcx: TyCtxt<'tcx>,
708    adt_def: AdtDef<'tcx>,
709    args: GenericArgsRef<'tcx>,
710) -> bool {
711    if adt_def.repr().inhibit_enum_layout_opt() {
712        return false;
713    }
714
715    let [var_one, var_two] = &adt_def.variants().raw[..] else {
716        return false;
717    };
718    let (([], [field]) | ([field], [])) = (&var_one.fields.raw[..], &var_two.fields.raw[..]) else {
719        return false;
720    };
721    matches!(field.ty(tcx, args).kind(), ty::FnPtr(..) | ty::Ref(..))
722}
723
724fn check_static_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) {
725    if tcx.codegen_fn_attrs(def_id).import_linkage.is_some() {
726        if match tcx.type_of(def_id).instantiate_identity().kind() {
727            ty::RawPtr(_, _) => false,
728            ty::Adt(adt_def, args) => !is_enum_of_nonnullable_ptr(tcx, *adt_def, *args),
729            _ => true,
730        } {
731            tcx.dcx().emit_err(errors::LinkageType { span: tcx.def_span(def_id) });
732        }
733    }
734}
735
736pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {
737    let mut res = Ok(());
738    let generics = tcx.generics_of(def_id);
739
740    for param in &generics.own_params {
741        match param.kind {
742            ty::GenericParamDefKind::Lifetime { .. } => {}
743            ty::GenericParamDefKind::Type { has_default, .. } => {
744                if has_default {
745                    tcx.ensure_ok().type_of(param.def_id);
746                }
747            }
748            ty::GenericParamDefKind::Const { has_default, .. } => {
749                tcx.ensure_ok().type_of(param.def_id);
750                if has_default {
751                    // need to store default and type of default
752                    let ct = tcx.const_param_default(param.def_id).skip_binder();
753                    if let ty::ConstKind::Unevaluated(uv) = ct.kind() {
754                        tcx.ensure_ok().type_of(uv.def);
755                    }
756                }
757            }
758        }
759    }
760
761    match tcx.def_kind(def_id) {
762        def_kind @ (DefKind::Static { .. } | DefKind::Const) => {
763            tcx.ensure_ok().generics_of(def_id);
764            tcx.ensure_ok().type_of(def_id);
765            tcx.ensure_ok().predicates_of(def_id);
766            match def_kind {
767                DefKind::Static { .. } => {
768                    check_static_inhabited(tcx, def_id);
769                    check_static_linkage(tcx, def_id);
770                    res = res.and(wfcheck::check_static_item(tcx, def_id));
771
772                    // Only `Node::Item` and `Node::ForeignItem` still have HIR based
773                    // checks. Returning early here does not miss any checks and
774                    // avoids this query from having a direct dependency edge on the HIR
775                    return res;
776                }
777                DefKind::Const => {}
778                _ => unreachable!(),
779            }
780        }
781        DefKind::Enum => {
782            tcx.ensure_ok().generics_of(def_id);
783            tcx.ensure_ok().type_of(def_id);
784            tcx.ensure_ok().predicates_of(def_id);
785            crate::collect::lower_enum_variant_types(tcx, def_id.to_def_id());
786            check_enum(tcx, def_id);
787            check_variances_for_type_defn(tcx, def_id);
788        }
789        DefKind::Fn => {
790            tcx.ensure_ok().generics_of(def_id);
791            tcx.ensure_ok().type_of(def_id);
792            tcx.ensure_ok().predicates_of(def_id);
793            tcx.ensure_ok().fn_sig(def_id);
794            tcx.ensure_ok().codegen_fn_attrs(def_id);
795            if let Some(i) = tcx.intrinsic(def_id) {
796                intrinsic::check_intrinsic_type(
797                    tcx,
798                    def_id,
799                    tcx.def_ident_span(def_id).unwrap(),
800                    i.name,
801                )
802            }
803        }
804        DefKind::Impl { of_trait } => {
805            tcx.ensure_ok().generics_of(def_id);
806            tcx.ensure_ok().type_of(def_id);
807            tcx.ensure_ok().impl_trait_header(def_id);
808            tcx.ensure_ok().predicates_of(def_id);
809            tcx.ensure_ok().associated_items(def_id);
810            if of_trait && let Some(impl_trait_header) = tcx.impl_trait_header(def_id) {
811                res = res.and(
812                    tcx.ensure_ok()
813                        .coherent_trait(impl_trait_header.trait_ref.instantiate_identity().def_id),
814                );
815
816                if res.is_ok() {
817                    // Checking this only makes sense if the all trait impls satisfy basic
818                    // requirements (see `coherent_trait` query), otherwise
819                    // we run into infinite recursions a lot.
820                    check_impl_items_against_trait(tcx, def_id, impl_trait_header);
821                }
822            }
823        }
824        DefKind::Trait => {
825            tcx.ensure_ok().generics_of(def_id);
826            tcx.ensure_ok().trait_def(def_id);
827            tcx.ensure_ok().explicit_super_predicates_of(def_id);
828            tcx.ensure_ok().predicates_of(def_id);
829            tcx.ensure_ok().associated_items(def_id);
830            let assoc_items = tcx.associated_items(def_id);
831            check_on_unimplemented(tcx, def_id);
832
833            for &assoc_item in assoc_items.in_definition_order() {
834                match assoc_item.kind {
835                    ty::AssocKind::Type { .. } if assoc_item.defaultness(tcx).has_value() => {
836                        let trait_args = GenericArgs::identity_for_item(tcx, def_id);
837                        let _: Result<_, rustc_errors::ErrorGuaranteed> = check_type_bounds(
838                            tcx,
839                            assoc_item,
840                            assoc_item,
841                            ty::TraitRef::new_from_args(tcx, def_id.to_def_id(), trait_args),
842                        );
843                    }
844                    _ => {}
845                }
846            }
847        }
848        DefKind::TraitAlias => {
849            tcx.ensure_ok().generics_of(def_id);
850            tcx.ensure_ok().explicit_implied_predicates_of(def_id);
851            tcx.ensure_ok().explicit_super_predicates_of(def_id);
852            tcx.ensure_ok().predicates_of(def_id);
853        }
854        def_kind @ (DefKind::Struct | DefKind::Union) => {
855            tcx.ensure_ok().generics_of(def_id);
856            tcx.ensure_ok().type_of(def_id);
857            tcx.ensure_ok().predicates_of(def_id);
858
859            let adt = tcx.adt_def(def_id).non_enum_variant();
860            for f in adt.fields.iter() {
861                tcx.ensure_ok().generics_of(f.did);
862                tcx.ensure_ok().type_of(f.did);
863                tcx.ensure_ok().predicates_of(f.did);
864            }
865
866            if let Some((_, ctor_def_id)) = adt.ctor {
867                crate::collect::lower_variant_ctor(tcx, ctor_def_id.expect_local());
868            }
869            match def_kind {
870                DefKind::Struct => check_struct(tcx, def_id),
871                DefKind::Union => check_union(tcx, def_id),
872                _ => unreachable!(),
873            }
874            check_variances_for_type_defn(tcx, def_id);
875        }
876        DefKind::OpaqueTy => {
877            check_opaque_precise_captures(tcx, def_id);
878
879            let origin = tcx.local_opaque_ty_origin(def_id);
880            if let hir::OpaqueTyOrigin::FnReturn { parent: fn_def_id, .. }
881            | hir::OpaqueTyOrigin::AsyncFn { parent: fn_def_id, .. } = origin
882                && let hir::Node::TraitItem(trait_item) = tcx.hir_node_by_def_id(fn_def_id)
883                && let (_, hir::TraitFn::Required(..)) = trait_item.expect_fn()
884            {
885                // Skip opaques from RPIT in traits with no default body.
886            } else {
887                check_opaque(tcx, def_id);
888            }
889
890            tcx.ensure_ok().predicates_of(def_id);
891            tcx.ensure_ok().explicit_item_bounds(def_id);
892            tcx.ensure_ok().explicit_item_self_bounds(def_id);
893            tcx.ensure_ok().item_bounds(def_id);
894            tcx.ensure_ok().item_self_bounds(def_id);
895            if tcx.is_conditionally_const(def_id) {
896                tcx.ensure_ok().explicit_implied_const_bounds(def_id);
897                tcx.ensure_ok().const_conditions(def_id);
898            }
899
900            // Only `Node::Item` and `Node::ForeignItem` still have HIR based
901            // checks. Returning early here does not miss any checks and
902            // avoids this query from having a direct dependency edge on the HIR
903            return res;
904        }
905        DefKind::TyAlias => {
906            tcx.ensure_ok().generics_of(def_id);
907            tcx.ensure_ok().type_of(def_id);
908            tcx.ensure_ok().predicates_of(def_id);
909            check_type_alias_type_params_are_used(tcx, def_id);
910            if tcx.type_alias_is_lazy(def_id) {
911                res = res.and(enter_wf_checking_ctxt(tcx, def_id, |wfcx| {
912                    let ty = tcx.type_of(def_id).instantiate_identity();
913                    let span = tcx.def_span(def_id);
914                    let item_ty = wfcx.deeply_normalize(span, Some(WellFormedLoc::Ty(def_id)), ty);
915                    wfcx.register_wf_obligation(
916                        span,
917                        Some(WellFormedLoc::Ty(def_id)),
918                        item_ty.into(),
919                    );
920                    check_where_clauses(wfcx, def_id);
921                    Ok(())
922                }));
923                check_variances_for_type_defn(tcx, def_id);
924            }
925        }
926        DefKind::ForeignMod => {
927            let it = tcx.hir_expect_item(def_id);
928            let hir::ItemKind::ForeignMod { abi, items } = it.kind else {
929                return Ok(());
930            };
931
932            check_abi(tcx, it.hir_id(), it.span, abi);
933
934            for item in items {
935                let def_id = item.id.owner_id.def_id;
936
937                let generics = tcx.generics_of(def_id);
938                let own_counts = generics.own_counts();
939                if generics.own_params.len() - own_counts.lifetimes != 0 {
940                    let (kinds, kinds_pl, egs) = match (own_counts.types, own_counts.consts) {
941                        (_, 0) => ("type", "types", Some("u32")),
942                        // We don't specify an example value, because we can't generate
943                        // a valid value for any type.
944                        (0, _) => ("const", "consts", None),
945                        _ => ("type or const", "types or consts", None),
946                    };
947                    struct_span_code_err!(
948                        tcx.dcx(),
949                        item.span,
950                        E0044,
951                        "foreign items may not have {kinds} parameters",
952                    )
953                    .with_span_label(item.span, format!("can't have {kinds} parameters"))
954                    .with_help(
955                        // FIXME: once we start storing spans for type arguments, turn this
956                        // into a suggestion.
957                        format!(
958                            "replace the {} parameters with concrete {}{}",
959                            kinds,
960                            kinds_pl,
961                            egs.map(|egs| format!(" like `{egs}`")).unwrap_or_default(),
962                        ),
963                    )
964                    .emit();
965                }
966
967                let item = tcx.hir_foreign_item(item.id);
968                tcx.ensure_ok().generics_of(item.owner_id);
969                tcx.ensure_ok().type_of(item.owner_id);
970                tcx.ensure_ok().predicates_of(item.owner_id);
971                if tcx.is_conditionally_const(def_id) {
972                    tcx.ensure_ok().explicit_implied_const_bounds(def_id);
973                    tcx.ensure_ok().const_conditions(def_id);
974                }
975                match item.kind {
976                    hir::ForeignItemKind::Fn(sig, ..) => {
977                        tcx.ensure_ok().codegen_fn_attrs(item.owner_id);
978                        tcx.ensure_ok().fn_sig(item.owner_id);
979                        require_c_abi_if_c_variadic(tcx, sig.decl, abi, item.span);
980                    }
981                    hir::ForeignItemKind::Static(..) => {
982                        tcx.ensure_ok().codegen_fn_attrs(item.owner_id);
983                    }
984                    _ => (),
985                }
986            }
987        }
988        DefKind::Closure => {
989            // This is guaranteed to be called by metadata encoding,
990            // we still call it in wfcheck eagerly to ensure errors in codegen
991            // attrs prevent lints from spamming the output.
992            tcx.ensure_ok().codegen_fn_attrs(def_id);
993            // We do not call `type_of` for closures here as that
994            // depends on typecheck and would therefore hide
995            // any further errors in case one typeck fails.
996
997            // Only `Node::Item` and `Node::ForeignItem` still have HIR based
998            // checks. Returning early here does not miss any checks and
999            // avoids this query from having a direct dependency edge on the HIR
1000            return res;
1001        }
1002        DefKind::AssocFn => {
1003            tcx.ensure_ok().codegen_fn_attrs(def_id);
1004            tcx.ensure_ok().type_of(def_id);
1005            tcx.ensure_ok().fn_sig(def_id);
1006            tcx.ensure_ok().predicates_of(def_id);
1007            res = res.and(check_associated_item(tcx, def_id));
1008            let assoc_item = tcx.associated_item(def_id);
1009            match assoc_item.container {
1010                ty::AssocItemContainer::Impl => {}
1011                ty::AssocItemContainer::Trait => {
1012                    res = res.and(check_trait_item(tcx, def_id));
1013                }
1014            }
1015
1016            // Only `Node::Item` and `Node::ForeignItem` still have HIR based
1017            // checks. Returning early here does not miss any checks and
1018            // avoids this query from having a direct dependency edge on the HIR
1019            return res;
1020        }
1021        DefKind::AssocConst => {
1022            tcx.ensure_ok().type_of(def_id);
1023            tcx.ensure_ok().predicates_of(def_id);
1024            res = res.and(check_associated_item(tcx, def_id));
1025            let assoc_item = tcx.associated_item(def_id);
1026            match assoc_item.container {
1027                ty::AssocItemContainer::Impl => {}
1028                ty::AssocItemContainer::Trait => {
1029                    res = res.and(check_trait_item(tcx, def_id));
1030                }
1031            }
1032
1033            // Only `Node::Item` and `Node::ForeignItem` still have HIR based
1034            // checks. Returning early here does not miss any checks and
1035            // avoids this query from having a direct dependency edge on the HIR
1036            return res;
1037        }
1038        DefKind::AssocTy => {
1039            tcx.ensure_ok().predicates_of(def_id);
1040            res = res.and(check_associated_item(tcx, def_id));
1041
1042            let assoc_item = tcx.associated_item(def_id);
1043            let has_type = match assoc_item.container {
1044                ty::AssocItemContainer::Impl => true,
1045                ty::AssocItemContainer::Trait => {
1046                    tcx.ensure_ok().item_bounds(def_id);
1047                    tcx.ensure_ok().item_self_bounds(def_id);
1048                    res = res.and(check_trait_item(tcx, def_id));
1049                    assoc_item.defaultness(tcx).has_value()
1050                }
1051            };
1052            if has_type {
1053                tcx.ensure_ok().type_of(def_id);
1054            }
1055
1056            // Only `Node::Item` and `Node::ForeignItem` still have HIR based
1057            // checks. Returning early here does not miss any checks and
1058            // avoids this query from having a direct dependency edge on the HIR
1059            return res;
1060        }
1061
1062        // Only `Node::Item` and `Node::ForeignItem` still have HIR based
1063        // checks. Returning early here does not miss any checks and
1064        // avoids this query from having a direct dependency edge on the HIR
1065        DefKind::AnonConst | DefKind::InlineConst => return res,
1066        _ => {}
1067    }
1068    let node = tcx.hir_node_by_def_id(def_id);
1069    res.and(match node {
1070        hir::Node::Crate(_) => bug!("check_well_formed cannot be applied to the crate root"),
1071        hir::Node::Item(item) => wfcheck::check_item(tcx, item),
1072        hir::Node::ForeignItem(item) => wfcheck::check_foreign_item(tcx, item),
1073        _ => unreachable!("{node:?}"),
1074    })
1075}
1076
1077pub(super) fn check_on_unimplemented(tcx: TyCtxt<'_>, def_id: LocalDefId) {
1078    // an error would be reported if this fails.
1079    let _ = OnUnimplementedDirective::of_item(tcx, def_id.to_def_id());
1080}
1081
1082pub(super) fn check_specialization_validity<'tcx>(
1083    tcx: TyCtxt<'tcx>,
1084    trait_def: &ty::TraitDef,
1085    trait_item: ty::AssocItem,
1086    impl_id: DefId,
1087    impl_item: DefId,
1088) {
1089    let Ok(ancestors) = trait_def.ancestors(tcx, impl_id) else { return };
1090    let mut ancestor_impls = ancestors.skip(1).filter_map(|parent| {
1091        if parent.is_from_trait() {
1092            None
1093        } else {
1094            Some((parent, parent.item(tcx, trait_item.def_id)))
1095        }
1096    });
1097
1098    let opt_result = ancestor_impls.find_map(|(parent_impl, parent_item)| {
1099        match parent_item {
1100            // Parent impl exists, and contains the parent item we're trying to specialize, but
1101            // doesn't mark it `default`.
1102            Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
1103                Some(Err(parent_impl.def_id()))
1104            }
1105
1106            // Parent impl contains item and makes it specializable.
1107            Some(_) => Some(Ok(())),
1108
1109            // Parent impl doesn't mention the item. This means it's inherited from the
1110            // grandparent. In that case, if parent is a `default impl`, inherited items use the
1111            // "defaultness" from the grandparent, else they are final.
1112            None => {
1113                if tcx.defaultness(parent_impl.def_id()).is_default() {
1114                    None
1115                } else {
1116                    Some(Err(parent_impl.def_id()))
1117                }
1118            }
1119        }
1120    });
1121
1122    // If `opt_result` is `None`, we have only encountered `default impl`s that don't contain the
1123    // item. This is allowed, the item isn't actually getting specialized here.
1124    let result = opt_result.unwrap_or(Ok(()));
1125
1126    if let Err(parent_impl) = result {
1127        if !tcx.is_impl_trait_in_trait(impl_item) {
1128            report_forbidden_specialization(tcx, impl_item, parent_impl);
1129        } else {
1130            tcx.dcx().delayed_bug(format!("parent item: {parent_impl:?} not marked as default"));
1131        }
1132    }
1133}
1134
1135fn check_impl_items_against_trait<'tcx>(
1136    tcx: TyCtxt<'tcx>,
1137    impl_id: LocalDefId,
1138    impl_trait_header: ty::ImplTraitHeader<'tcx>,
1139) {
1140    let trait_ref = impl_trait_header.trait_ref.instantiate_identity();
1141    // If the trait reference itself is erroneous (so the compilation is going
1142    // to fail), skip checking the items here -- the `impl_item` table in `tcx`
1143    // isn't populated for such impls.
1144    if trait_ref.references_error() {
1145        return;
1146    }
1147
1148    let impl_item_refs = tcx.associated_item_def_ids(impl_id);
1149
1150    // Negative impls are not expected to have any items
1151    match impl_trait_header.polarity {
1152        ty::ImplPolarity::Reservation | ty::ImplPolarity::Positive => {}
1153        ty::ImplPolarity::Negative => {
1154            if let [first_item_ref, ..] = impl_item_refs {
1155                let first_item_span = tcx.def_span(first_item_ref);
1156                struct_span_code_err!(
1157                    tcx.dcx(),
1158                    first_item_span,
1159                    E0749,
1160                    "negative impls cannot have any items"
1161                )
1162                .emit();
1163            }
1164            return;
1165        }
1166    }
1167
1168    let trait_def = tcx.trait_def(trait_ref.def_id);
1169
1170    let self_is_guaranteed_unsize_self = tcx.impl_self_is_guaranteed_unsized(impl_id);
1171
1172    for &impl_item in impl_item_refs {
1173        let ty_impl_item = tcx.associated_item(impl_item);
1174        let ty_trait_item = if let Some(trait_item_id) = ty_impl_item.trait_item_def_id {
1175            tcx.associated_item(trait_item_id)
1176        } else {
1177            // Checked in `associated_item`.
1178            tcx.dcx().span_delayed_bug(tcx.def_span(impl_item), "missing associated item in trait");
1179            continue;
1180        };
1181
1182        let res = tcx.ensure_ok().compare_impl_item(impl_item.expect_local());
1183
1184        if res.is_ok() {
1185            match ty_impl_item.kind {
1186                ty::AssocKind::Fn { .. } => {
1187                    compare_impl_item::refine::check_refining_return_position_impl_trait_in_trait(
1188                        tcx,
1189                        ty_impl_item,
1190                        ty_trait_item,
1191                        tcx.impl_trait_ref(ty_impl_item.container_id(tcx))
1192                            .unwrap()
1193                            .instantiate_identity(),
1194                    );
1195                }
1196                ty::AssocKind::Const { .. } => {}
1197                ty::AssocKind::Type { .. } => {}
1198            }
1199        }
1200
1201        if self_is_guaranteed_unsize_self && tcx.generics_require_sized_self(ty_trait_item.def_id) {
1202            tcx.emit_node_span_lint(
1203                rustc_lint_defs::builtin::DEAD_CODE,
1204                tcx.local_def_id_to_hir_id(ty_impl_item.def_id.expect_local()),
1205                tcx.def_span(ty_impl_item.def_id),
1206                errors::UselessImplItem,
1207            )
1208        }
1209
1210        check_specialization_validity(
1211            tcx,
1212            trait_def,
1213            ty_trait_item,
1214            impl_id.to_def_id(),
1215            impl_item,
1216        );
1217    }
1218
1219    if let Ok(ancestors) = trait_def.ancestors(tcx, impl_id.to_def_id()) {
1220        // Check for missing items from trait
1221        let mut missing_items = Vec::new();
1222
1223        let mut must_implement_one_of: Option<&[Ident]> =
1224            trait_def.must_implement_one_of.as_deref();
1225
1226        for &trait_item_id in tcx.associated_item_def_ids(trait_ref.def_id) {
1227            let leaf_def = ancestors.leaf_def(tcx, trait_item_id);
1228
1229            let is_implemented = leaf_def
1230                .as_ref()
1231                .is_some_and(|node_item| node_item.item.defaultness(tcx).has_value());
1232
1233            if !is_implemented
1234                && tcx.defaultness(impl_id).is_final()
1235                // unsized types don't need to implement methods that have `Self: Sized` bounds.
1236                && !(self_is_guaranteed_unsize_self && tcx.generics_require_sized_self(trait_item_id))
1237            {
1238                missing_items.push(tcx.associated_item(trait_item_id));
1239            }
1240
1241            // true if this item is specifically implemented in this impl
1242            let is_implemented_here =
1243                leaf_def.as_ref().is_some_and(|node_item| !node_item.defining_node.is_from_trait());
1244
1245            if !is_implemented_here {
1246                let full_impl_span = tcx.hir_span_with_body(tcx.local_def_id_to_hir_id(impl_id));
1247                match tcx.eval_default_body_stability(trait_item_id, full_impl_span) {
1248                    EvalResult::Deny { feature, reason, issue, .. } => default_body_is_unstable(
1249                        tcx,
1250                        full_impl_span,
1251                        trait_item_id,
1252                        feature,
1253                        reason,
1254                        issue,
1255                    ),
1256
1257                    // Unmarked default bodies are considered stable (at least for now).
1258                    EvalResult::Allow | EvalResult::Unmarked => {}
1259                }
1260            }
1261
1262            if let Some(required_items) = &must_implement_one_of {
1263                if is_implemented_here {
1264                    let trait_item = tcx.associated_item(trait_item_id);
1265                    if required_items.contains(&trait_item.ident(tcx)) {
1266                        must_implement_one_of = None;
1267                    }
1268                }
1269            }
1270
1271            if let Some(leaf_def) = &leaf_def
1272                && !leaf_def.is_final()
1273                && let def_id = leaf_def.item.def_id
1274                && tcx.impl_method_has_trait_impl_trait_tys(def_id)
1275            {
1276                let def_kind = tcx.def_kind(def_id);
1277                let descr = tcx.def_kind_descr(def_kind, def_id);
1278                let (msg, feature) = if tcx.asyncness(def_id).is_async() {
1279                    (
1280                        format!("async {descr} in trait cannot be specialized"),
1281                        "async functions in traits",
1282                    )
1283                } else {
1284                    (
1285                        format!(
1286                            "{descr} with return-position `impl Trait` in trait cannot be specialized"
1287                        ),
1288                        "return position `impl Trait` in traits",
1289                    )
1290                };
1291                tcx.dcx()
1292                    .struct_span_err(tcx.def_span(def_id), msg)
1293                    .with_note(format!(
1294                        "specialization behaves in inconsistent and surprising ways with \
1295                        {feature}, and for now is disallowed"
1296                    ))
1297                    .emit();
1298            }
1299        }
1300
1301        if !missing_items.is_empty() {
1302            let full_impl_span = tcx.hir_span_with_body(tcx.local_def_id_to_hir_id(impl_id));
1303            missing_items_err(tcx, impl_id, &missing_items, full_impl_span);
1304        }
1305
1306        if let Some(missing_items) = must_implement_one_of {
1307            let attr_span = tcx
1308                .get_attr(trait_ref.def_id, sym::rustc_must_implement_one_of)
1309                .map(|attr| attr.span());
1310
1311            missing_items_must_implement_one_of_err(
1312                tcx,
1313                tcx.def_span(impl_id),
1314                missing_items,
1315                attr_span,
1316            );
1317        }
1318    }
1319}
1320
1321fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
1322    let t = tcx.type_of(def_id).instantiate_identity();
1323    if let ty::Adt(def, args) = t.kind()
1324        && def.is_struct()
1325    {
1326        let fields = &def.non_enum_variant().fields;
1327        if fields.is_empty() {
1328            struct_span_code_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot be empty").emit();
1329            return;
1330        }
1331
1332        let array_field = &fields[FieldIdx::ZERO];
1333        let array_ty = array_field.ty(tcx, args);
1334        let ty::Array(element_ty, len_const) = array_ty.kind() else {
1335            struct_span_code_err!(
1336                tcx.dcx(),
1337                sp,
1338                E0076,
1339                "SIMD vector's only field must be an array"
1340            )
1341            .with_span_label(tcx.def_span(array_field.did), "not an array")
1342            .emit();
1343            return;
1344        };
1345
1346        if let Some(second_field) = fields.get(FieldIdx::ONE) {
1347            struct_span_code_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot have multiple fields")
1348                .with_span_label(tcx.def_span(second_field.did), "excess field")
1349                .emit();
1350            return;
1351        }
1352
1353        // FIXME(repr_simd): This check is nice, but perhaps unnecessary due to the fact
1354        // we do not expect users to implement their own `repr(simd)` types. If they could,
1355        // this check is easily side-steppable by hiding the const behind normalization.
1356        // The consequence is that the error is, in general, only observable post-mono.
1357        if let Some(len) = len_const.try_to_target_usize(tcx) {
1358            if len == 0 {
1359                struct_span_code_err!(tcx.dcx(), sp, E0075, "SIMD vector cannot be empty").emit();
1360                return;
1361            } else if len > MAX_SIMD_LANES {
1362                struct_span_code_err!(
1363                    tcx.dcx(),
1364                    sp,
1365                    E0075,
1366                    "SIMD vector cannot have more than {MAX_SIMD_LANES} elements",
1367                )
1368                .emit();
1369                return;
1370            }
1371        }
1372
1373        // Check that we use types valid for use in the lanes of a SIMD "vector register"
1374        // These are scalar types which directly match a "machine" type
1375        // Yes: Integers, floats, "thin" pointers
1376        // No: char, "wide" pointers, compound types
1377        match element_ty.kind() {
1378            ty::Param(_) => (), // pass struct<T>([T; 4]) through, let monomorphization catch errors
1379            ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_, _) => (), // struct([u8; 4]) is ok
1380            _ => {
1381                struct_span_code_err!(
1382                    tcx.dcx(),
1383                    sp,
1384                    E0077,
1385                    "SIMD vector element type should be a \
1386                        primitive scalar (integer/float/pointer) type"
1387                )
1388                .emit();
1389                return;
1390            }
1391        }
1392    }
1393}
1394
1395pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
1396    let repr = def.repr();
1397    if repr.packed() {
1398        if let Some(reprs) = attrs::find_attr!(tcx.get_all_attrs(def.did()), attrs::AttributeKind::Repr { reprs, .. } => reprs)
1399        {
1400            for (r, _) in reprs {
1401                if let ReprPacked(pack) = r
1402                    && let Some(repr_pack) = repr.pack
1403                    && pack != &repr_pack
1404                {
1405                    struct_span_code_err!(
1406                        tcx.dcx(),
1407                        sp,
1408                        E0634,
1409                        "type has conflicting packed representation hints"
1410                    )
1411                    .emit();
1412                }
1413            }
1414        }
1415        if repr.align.is_some() {
1416            struct_span_code_err!(
1417                tcx.dcx(),
1418                sp,
1419                E0587,
1420                "type has conflicting packed and align representation hints"
1421            )
1422            .emit();
1423        } else if let Some(def_spans) = check_packed_inner(tcx, def.did(), &mut vec![]) {
1424            let mut err = struct_span_code_err!(
1425                tcx.dcx(),
1426                sp,
1427                E0588,
1428                "packed type cannot transitively contain a `#[repr(align)]` type"
1429            );
1430
1431            err.span_note(
1432                tcx.def_span(def_spans[0].0),
1433                format!("`{}` has a `#[repr(align)]` attribute", tcx.item_name(def_spans[0].0)),
1434            );
1435
1436            if def_spans.len() > 2 {
1437                let mut first = true;
1438                for (adt_def, span) in def_spans.iter().skip(1).rev() {
1439                    let ident = tcx.item_name(*adt_def);
1440                    err.span_note(
1441                        *span,
1442                        if first {
1443                            format!(
1444                                "`{}` contains a field of type `{}`",
1445                                tcx.type_of(def.did()).instantiate_identity(),
1446                                ident
1447                            )
1448                        } else {
1449                            format!("...which contains a field of type `{ident}`")
1450                        },
1451                    );
1452                    first = false;
1453                }
1454            }
1455
1456            err.emit();
1457        }
1458    }
1459}
1460
1461pub(super) fn check_packed_inner(
1462    tcx: TyCtxt<'_>,
1463    def_id: DefId,
1464    stack: &mut Vec<DefId>,
1465) -> Option<Vec<(DefId, Span)>> {
1466    if let ty::Adt(def, args) = tcx.type_of(def_id).instantiate_identity().kind() {
1467        if def.is_struct() || def.is_union() {
1468            if def.repr().align.is_some() {
1469                return Some(vec![(def.did(), DUMMY_SP)]);
1470            }
1471
1472            stack.push(def_id);
1473            for field in &def.non_enum_variant().fields {
1474                if let ty::Adt(def, _) = field.ty(tcx, args).kind()
1475                    && !stack.contains(&def.did())
1476                    && let Some(mut defs) = check_packed_inner(tcx, def.did(), stack)
1477                {
1478                    defs.push((def.did(), field.ident(tcx).span));
1479                    return Some(defs);
1480                }
1481            }
1482            stack.pop();
1483        }
1484    }
1485
1486    None
1487}
1488
1489pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>) {
1490    if !adt.repr().transparent() {
1491        return;
1492    }
1493
1494    if adt.is_union() && !tcx.features().transparent_unions() {
1495        feature_err(
1496            &tcx.sess,
1497            sym::transparent_unions,
1498            tcx.def_span(adt.did()),
1499            "transparent unions are unstable",
1500        )
1501        .emit();
1502    }
1503
1504    if adt.variants().len() != 1 {
1505        bad_variant_count(tcx, adt, tcx.def_span(adt.did()), adt.did());
1506        // Don't bother checking the fields.
1507        return;
1508    }
1509
1510    // For each field, figure out if it's known to have "trivial" layout (i.e., is a 1-ZST), with
1511    // "known" respecting #[non_exhaustive] attributes.
1512    let field_infos = adt.all_fields().map(|field| {
1513        let ty = field.ty(tcx, GenericArgs::identity_for_item(tcx, field.did));
1514        let typing_env = ty::TypingEnv::non_body_analysis(tcx, field.did);
1515        let layout = tcx.layout_of(typing_env.as_query_input(ty));
1516        // We are currently checking the type this field came from, so it must be local
1517        let span = tcx.hir_span_if_local(field.did).unwrap();
1518        let trivial = layout.is_ok_and(|layout| layout.is_1zst());
1519        if !trivial {
1520            return (span, trivial, None);
1521        }
1522        // Even some 1-ZST fields are not allowed though, if they have `non_exhaustive`.
1523
1524        fn check_non_exhaustive<'tcx>(
1525            tcx: TyCtxt<'tcx>,
1526            t: Ty<'tcx>,
1527        ) -> ControlFlow<(&'static str, DefId, GenericArgsRef<'tcx>, bool)> {
1528            match t.kind() {
1529                ty::Tuple(list) => list.iter().try_for_each(|t| check_non_exhaustive(tcx, t)),
1530                ty::Array(ty, _) => check_non_exhaustive(tcx, *ty),
1531                ty::Adt(def, args) => {
1532                    if !def.did().is_local()
1533                        && !attrs::find_attr!(
1534                            tcx.get_all_attrs(def.did()),
1535                            AttributeKind::PubTransparent(_)
1536                        )
1537                    {
1538                        let non_exhaustive = def.is_variant_list_non_exhaustive()
1539                            || def
1540                                .variants()
1541                                .iter()
1542                                .any(ty::VariantDef::is_field_list_non_exhaustive);
1543                        let has_priv = def.all_fields().any(|f| !f.vis.is_public());
1544                        if non_exhaustive || has_priv {
1545                            return ControlFlow::Break((
1546                                def.descr(),
1547                                def.did(),
1548                                args,
1549                                non_exhaustive,
1550                            ));
1551                        }
1552                    }
1553                    def.all_fields()
1554                        .map(|field| field.ty(tcx, args))
1555                        .try_for_each(|t| check_non_exhaustive(tcx, t))
1556                }
1557                _ => ControlFlow::Continue(()),
1558            }
1559        }
1560
1561        (span, trivial, check_non_exhaustive(tcx, ty).break_value())
1562    });
1563
1564    let non_trivial_fields = field_infos
1565        .clone()
1566        .filter_map(|(span, trivial, _non_exhaustive)| if !trivial { Some(span) } else { None });
1567    let non_trivial_count = non_trivial_fields.clone().count();
1568    if non_trivial_count >= 2 {
1569        bad_non_zero_sized_fields(
1570            tcx,
1571            adt,
1572            non_trivial_count,
1573            non_trivial_fields,
1574            tcx.def_span(adt.did()),
1575        );
1576        return;
1577    }
1578    let mut prev_non_exhaustive_1zst = false;
1579    for (span, _trivial, non_exhaustive_1zst) in field_infos {
1580        if let Some((descr, def_id, args, non_exhaustive)) = non_exhaustive_1zst {
1581            // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
1582            // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
1583            if non_trivial_count > 0 || prev_non_exhaustive_1zst {
1584                tcx.node_span_lint(
1585                    REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS,
1586                    tcx.local_def_id_to_hir_id(adt.did().expect_local()),
1587                    span,
1588                    |lint| {
1589                        lint.primary_message(
1590                            "zero-sized fields in `repr(transparent)` cannot \
1591                             contain external non-exhaustive types",
1592                        );
1593                        let note = if non_exhaustive {
1594                            "is marked with `#[non_exhaustive]`"
1595                        } else {
1596                            "contains private fields"
1597                        };
1598                        let field_ty = tcx.def_path_str_with_args(def_id, args);
1599                        lint.note(format!(
1600                            "this {descr} contains `{field_ty}`, which {note}, \
1601                                and makes it not a breaking change to become \
1602                                non-zero-sized in the future."
1603                        ));
1604                    },
1605                )
1606            } else {
1607                prev_non_exhaustive_1zst = true;
1608            }
1609        }
1610    }
1611}
1612
1613#[allow(trivial_numeric_casts)]
1614fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
1615    let def = tcx.adt_def(def_id);
1616    def.destructor(tcx); // force the destructor to be evaluated
1617
1618    if def.variants().is_empty() {
1619        attrs::find_attr!(
1620            tcx.get_all_attrs(def_id),
1621            attrs::AttributeKind::Repr { reprs, first_span } => {
1622                struct_span_code_err!(
1623                    tcx.dcx(),
1624                    reprs.first().map(|repr| repr.1).unwrap_or(*first_span),
1625                    E0084,
1626                    "unsupported representation for zero-variant enum"
1627                )
1628                .with_span_label(tcx.def_span(def_id), "zero-variant enum")
1629                .emit();
1630            }
1631        );
1632    }
1633
1634    for v in def.variants() {
1635        if let ty::VariantDiscr::Explicit(discr_def_id) = v.discr {
1636            tcx.ensure_ok().typeck(discr_def_id.expect_local());
1637        }
1638    }
1639
1640    if def.repr().int.is_none() {
1641        let is_unit = |var: &ty::VariantDef| matches!(var.ctor_kind(), Some(CtorKind::Const));
1642        let has_disr = |var: &ty::VariantDef| matches!(var.discr, ty::VariantDiscr::Explicit(_));
1643
1644        let has_non_units = def.variants().iter().any(|var| !is_unit(var));
1645        let disr_units = def.variants().iter().any(|var| is_unit(var) && has_disr(var));
1646        let disr_non_unit = def.variants().iter().any(|var| !is_unit(var) && has_disr(var));
1647
1648        if disr_non_unit || (disr_units && has_non_units) {
1649            struct_span_code_err!(
1650                tcx.dcx(),
1651                tcx.def_span(def_id),
1652                E0732,
1653                "`#[repr(inttype)]` must be specified"
1654            )
1655            .emit();
1656        }
1657    }
1658
1659    detect_discriminant_duplicate(tcx, def);
1660    check_transparent(tcx, def);
1661}
1662
1663/// Part of enum check. Given the discriminants of an enum, errors if two or more discriminants are equal
1664fn detect_discriminant_duplicate<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>) {
1665    // Helper closure to reduce duplicate code. This gets called everytime we detect a duplicate.
1666    // Here `idx` refers to the order of which the discriminant appears, and its index in `vs`
1667    let report = |dis: Discr<'tcx>, idx, err: &mut Diag<'_>| {
1668        let var = adt.variant(idx); // HIR for the duplicate discriminant
1669        let (span, display_discr) = match var.discr {
1670            ty::VariantDiscr::Explicit(discr_def_id) => {
1671                // In the case the discriminant is both a duplicate and overflowed, let the user know
1672                if let hir::Node::AnonConst(expr) =
1673                    tcx.hir_node_by_def_id(discr_def_id.expect_local())
1674                    && let hir::ExprKind::Lit(lit) = &tcx.hir_body(expr.body).value.kind
1675                    && let rustc_ast::LitKind::Int(lit_value, _int_kind) = &lit.node
1676                    && *lit_value != dis.val
1677                {
1678                    (tcx.def_span(discr_def_id), format!("`{dis}` (overflowed from `{lit_value}`)"))
1679                } else {
1680                    // Otherwise, format the value as-is
1681                    (tcx.def_span(discr_def_id), format!("`{dis}`"))
1682                }
1683            }
1684            // This should not happen.
1685            ty::VariantDiscr::Relative(0) => (tcx.def_span(var.def_id), format!("`{dis}`")),
1686            ty::VariantDiscr::Relative(distance_to_explicit) => {
1687                // At this point we know this discriminant is a duplicate, and was not explicitly
1688                // assigned by the user. Here we iterate backwards to fetch the HIR for the last
1689                // explicitly assigned discriminant, and letting the user know that this was the
1690                // increment startpoint, and how many steps from there leading to the duplicate
1691                if let Some(explicit_idx) =
1692                    idx.as_u32().checked_sub(distance_to_explicit).map(VariantIdx::from_u32)
1693                {
1694                    let explicit_variant = adt.variant(explicit_idx);
1695                    let ve_ident = var.name;
1696                    let ex_ident = explicit_variant.name;
1697                    let sp = if distance_to_explicit > 1 { "variants" } else { "variant" };
1698
1699                    err.span_label(
1700                        tcx.def_span(explicit_variant.def_id),
1701                        format!(
1702                            "discriminant for `{ve_ident}` incremented from this startpoint \
1703                            (`{ex_ident}` + {distance_to_explicit} {sp} later \
1704                             => `{ve_ident}` = {dis})"
1705                        ),
1706                    );
1707                }
1708
1709                (tcx.def_span(var.def_id), format!("`{dis}`"))
1710            }
1711        };
1712
1713        err.span_label(span, format!("{display_discr} assigned here"));
1714    };
1715
1716    let mut discrs = adt.discriminants(tcx).collect::<Vec<_>>();
1717
1718    // Here we loop through the discriminants, comparing each discriminant to another.
1719    // When a duplicate is detected, we instantiate an error and point to both
1720    // initial and duplicate value. The duplicate discriminant is then discarded by swapping
1721    // it with the last element and decrementing the `vec.len` (which is why we have to evaluate
1722    // `discrs.len()` anew every iteration, and why this could be tricky to do in a functional
1723    // style as we are mutating `discrs` on the fly).
1724    let mut i = 0;
1725    while i < discrs.len() {
1726        let var_i_idx = discrs[i].0;
1727        let mut error: Option<Diag<'_, _>> = None;
1728
1729        let mut o = i + 1;
1730        while o < discrs.len() {
1731            let var_o_idx = discrs[o].0;
1732
1733            if discrs[i].1.val == discrs[o].1.val {
1734                let err = error.get_or_insert_with(|| {
1735                    let mut ret = struct_span_code_err!(
1736                        tcx.dcx(),
1737                        tcx.def_span(adt.did()),
1738                        E0081,
1739                        "discriminant value `{}` assigned more than once",
1740                        discrs[i].1,
1741                    );
1742
1743                    report(discrs[i].1, var_i_idx, &mut ret);
1744
1745                    ret
1746                });
1747
1748                report(discrs[o].1, var_o_idx, err);
1749
1750                // Safe to unwrap here, as we wouldn't reach this point if `discrs` was empty
1751                discrs[o] = *discrs.last().unwrap();
1752                discrs.pop();
1753            } else {
1754                o += 1;
1755            }
1756        }
1757
1758        if let Some(e) = error {
1759            e.emit();
1760        }
1761
1762        i += 1;
1763    }
1764}
1765
1766fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) {
1767    if tcx.type_alias_is_lazy(def_id) {
1768        // Since we compute the variances for lazy type aliases and already reject bivariant
1769        // parameters as unused, we can and should skip this check for lazy type aliases.
1770        return;
1771    }
1772
1773    let generics = tcx.generics_of(def_id);
1774    if generics.own_counts().types == 0 {
1775        return;
1776    }
1777
1778    let ty = tcx.type_of(def_id).instantiate_identity();
1779    if ty.references_error() {
1780        // If there is already another error, do not emit an error for not using a type parameter.
1781        return;
1782    }
1783
1784    // Lazily calculated because it is only needed in case of an error.
1785    let bounded_params = LazyCell::new(|| {
1786        tcx.explicit_predicates_of(def_id)
1787            .predicates
1788            .iter()
1789            .filter_map(|(predicate, span)| {
1790                let bounded_ty = match predicate.kind().skip_binder() {
1791                    ty::ClauseKind::Trait(pred) => pred.trait_ref.self_ty(),
1792                    ty::ClauseKind::TypeOutlives(pred) => pred.0,
1793                    _ => return None,
1794                };
1795                if let ty::Param(param) = bounded_ty.kind() {
1796                    Some((param.index, span))
1797                } else {
1798                    None
1799                }
1800            })
1801            // FIXME: This assumes that elaborated `Sized` bounds come first (which does hold at the
1802            // time of writing). This is a bit fragile since we later use the span to detect elaborated
1803            // `Sized` bounds. If they came last for example, this would break `Trait + /*elab*/Sized`
1804            // since it would overwrite the span of the user-written bound. This could be fixed by
1805            // folding the spans with `Span::to` which requires a bit of effort I think.
1806            .collect::<FxIndexMap<_, _>>()
1807    });
1808
1809    let mut params_used = DenseBitSet::new_empty(generics.own_params.len());
1810    for leaf in ty.walk() {
1811        if let GenericArgKind::Type(leaf_ty) = leaf.kind()
1812            && let ty::Param(param) = leaf_ty.kind()
1813        {
1814            debug!("found use of ty param {:?}", param);
1815            params_used.insert(param.index);
1816        }
1817    }
1818
1819    for param in &generics.own_params {
1820        if !params_used.contains(param.index)
1821            && let ty::GenericParamDefKind::Type { .. } = param.kind
1822        {
1823            let span = tcx.def_span(param.def_id);
1824            let param_name = Ident::new(param.name, span);
1825
1826            // The corresponding predicates are post-`Sized`-elaboration. Therefore we
1827            // * check for emptiness to detect lone user-written `?Sized` bounds
1828            // * compare the param span to the pred span to detect lone user-written `Sized` bounds
1829            let has_explicit_bounds = bounded_params.is_empty()
1830                || (*bounded_params).get(&param.index).is_some_and(|&&pred_sp| pred_sp != span);
1831            let const_param_help = !has_explicit_bounds;
1832
1833            let mut diag = tcx.dcx().create_err(errors::UnusedGenericParameter {
1834                span,
1835                param_name,
1836                param_def_kind: tcx.def_descr(param.def_id),
1837                help: errors::UnusedGenericParameterHelp::TyAlias { param_name },
1838                usage_spans: vec![],
1839                const_param_help,
1840            });
1841            diag.code(E0091);
1842            diag.emit();
1843        }
1844    }
1845}
1846
1847/// Emit an error for recursive opaque types.
1848///
1849/// If this is a return `impl Trait`, find the item's return expressions and point at them. For
1850/// direct recursion this is enough, but for indirect recursion also point at the last intermediary
1851/// `impl Trait`.
1852///
1853/// If all the return expressions evaluate to `!`, then we explain that the error will go away
1854/// after changing it. This can happen when a user uses `panic!()` or similar as a placeholder.
1855fn opaque_type_cycle_error(tcx: TyCtxt<'_>, opaque_def_id: LocalDefId) -> ErrorGuaranteed {
1856    let span = tcx.def_span(opaque_def_id);
1857    let mut err = struct_span_code_err!(tcx.dcx(), span, E0720, "cannot resolve opaque type");
1858
1859    let mut label = false;
1860    if let Some((def_id, visitor)) = get_owner_return_paths(tcx, opaque_def_id) {
1861        let typeck_results = tcx.typeck(def_id);
1862        if visitor
1863            .returns
1864            .iter()
1865            .filter_map(|expr| typeck_results.node_type_opt(expr.hir_id))
1866            .all(|ty| matches!(ty.kind(), ty::Never))
1867        {
1868            let spans = visitor
1869                .returns
1870                .iter()
1871                .filter(|expr| typeck_results.node_type_opt(expr.hir_id).is_some())
1872                .map(|expr| expr.span)
1873                .collect::<Vec<Span>>();
1874            let span_len = spans.len();
1875            if span_len == 1 {
1876                err.span_label(spans[0], "this returned value is of `!` type");
1877            } else {
1878                let mut multispan: MultiSpan = spans.clone().into();
1879                for span in spans {
1880                    multispan.push_span_label(span, "this returned value is of `!` type");
1881                }
1882                err.span_note(multispan, "these returned values have a concrete \"never\" type");
1883            }
1884            err.help("this error will resolve once the item's body returns a concrete type");
1885        } else {
1886            let mut seen = FxHashSet::default();
1887            seen.insert(span);
1888            err.span_label(span, "recursive opaque type");
1889            label = true;
1890            for (sp, ty) in visitor
1891                .returns
1892                .iter()
1893                .filter_map(|e| typeck_results.node_type_opt(e.hir_id).map(|t| (e.span, t)))
1894                .filter(|(_, ty)| !matches!(ty.kind(), ty::Never))
1895            {
1896                #[derive(Default)]
1897                struct OpaqueTypeCollector {
1898                    opaques: Vec<DefId>,
1899                    closures: Vec<DefId>,
1900                }
1901                impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for OpaqueTypeCollector {
1902                    fn visit_ty(&mut self, t: Ty<'tcx>) {
1903                        match *t.kind() {
1904                            ty::Alias(ty::Opaque, ty::AliasTy { def_id: def, .. }) => {
1905                                self.opaques.push(def);
1906                            }
1907                            ty::Closure(def_id, ..) | ty::Coroutine(def_id, ..) => {
1908                                self.closures.push(def_id);
1909                                t.super_visit_with(self);
1910                            }
1911                            _ => t.super_visit_with(self),
1912                        }
1913                    }
1914                }
1915
1916                let mut visitor = OpaqueTypeCollector::default();
1917                ty.visit_with(&mut visitor);
1918                for def_id in visitor.opaques {
1919                    let ty_span = tcx.def_span(def_id);
1920                    if !seen.contains(&ty_span) {
1921                        let descr = if ty.is_impl_trait() { "opaque " } else { "" };
1922                        err.span_label(ty_span, format!("returning this {descr}type `{ty}`"));
1923                        seen.insert(ty_span);
1924                    }
1925                    err.span_label(sp, format!("returning here with type `{ty}`"));
1926                }
1927
1928                for closure_def_id in visitor.closures {
1929                    let Some(closure_local_did) = closure_def_id.as_local() else {
1930                        continue;
1931                    };
1932                    let typeck_results = tcx.typeck(closure_local_did);
1933
1934                    let mut label_match = |ty: Ty<'_>, span| {
1935                        for arg in ty.walk() {
1936                            if let ty::GenericArgKind::Type(ty) = arg.kind()
1937                                && let ty::Alias(
1938                                    ty::Opaque,
1939                                    ty::AliasTy { def_id: captured_def_id, .. },
1940                                ) = *ty.kind()
1941                                && captured_def_id == opaque_def_id.to_def_id()
1942                            {
1943                                err.span_label(
1944                                    span,
1945                                    format!(
1946                                        "{} captures itself here",
1947                                        tcx.def_descr(closure_def_id)
1948                                    ),
1949                                );
1950                            }
1951                        }
1952                    };
1953
1954                    // Label any closure upvars that capture the opaque
1955                    for capture in typeck_results.closure_min_captures_flattened(closure_local_did)
1956                    {
1957                        label_match(capture.place.ty(), capture.get_path_span(tcx));
1958                    }
1959                    // Label any coroutine locals that capture the opaque
1960                    if tcx.is_coroutine(closure_def_id)
1961                        && let Some(coroutine_layout) = tcx.mir_coroutine_witnesses(closure_def_id)
1962                    {
1963                        for interior_ty in &coroutine_layout.field_tys {
1964                            label_match(interior_ty.ty, interior_ty.source_info.span);
1965                        }
1966                    }
1967                }
1968            }
1969        }
1970    }
1971    if !label {
1972        err.span_label(span, "cannot resolve opaque type");
1973    }
1974    err.emit()
1975}
1976
1977pub(super) fn check_coroutine_obligations(
1978    tcx: TyCtxt<'_>,
1979    def_id: LocalDefId,
1980) -> Result<(), ErrorGuaranteed> {
1981    debug_assert!(!tcx.is_typeck_child(def_id.to_def_id()));
1982
1983    let typeck_results = tcx.typeck(def_id);
1984    let param_env = tcx.param_env(def_id);
1985
1986    debug!(?typeck_results.coroutine_stalled_predicates);
1987
1988    let mode = if tcx.next_trait_solver_globally() {
1989        // This query is conceptually between HIR typeck and
1990        // MIR borrowck. We use the opaque types defined by HIR
1991        // and ignore region constraints.
1992        TypingMode::borrowck(tcx, def_id)
1993    } else {
1994        TypingMode::analysis_in_body(tcx, def_id)
1995    };
1996
1997    // Typeck writeback gives us predicates with their regions erased.
1998    // We only need to check the goals while ignoring lifetimes to give good
1999    // error message and to avoid breaking the assumption of `mir_borrowck`
2000    // that all obligations already hold modulo regions.
2001    let infcx = tcx.infer_ctxt().ignoring_regions().build(mode);
2002
2003    let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
2004    for (predicate, cause) in &typeck_results.coroutine_stalled_predicates {
2005        ocx.register_obligation(Obligation::new(tcx, cause.clone(), param_env, *predicate));
2006    }
2007
2008    let errors = ocx.select_all_or_error();
2009    debug!(?errors);
2010    if !errors.is_empty() {
2011        return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
2012    }
2013
2014    if !tcx.next_trait_solver_globally() {
2015        // Check that any hidden types found when checking these stalled coroutine obligations
2016        // are valid.
2017        for (key, ty) in infcx.take_opaque_types() {
2018            let hidden_type = infcx.resolve_vars_if_possible(ty);
2019            let key = infcx.resolve_vars_if_possible(key);
2020            sanity_check_found_hidden_type(tcx, key, hidden_type)?;
2021        }
2022    } else {
2023        // We're not checking region constraints here, so we can simply drop the
2024        // added opaque type uses in `TypingMode::Borrowck`.
2025        let _ = infcx.take_opaque_types();
2026    }
2027
2028    Ok(())
2029}