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 match AbiMap::from_target(&tcx.sess.target).canonize_abi(abi, false) {
64 AbiMapping::Direct(..) => (),
65 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 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); 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); 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 if ty.is_trivially_pure_clone_copy() {
125 return true;
126 }
127 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
146fn 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 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
176fn check_static_inhabited(tcx: TyCtxt<'_>, def_id: LocalDefId) {
178 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 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 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
215fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
218 let hir::OpaqueTy { origin, .. } = *tcx.hir_expect_opaque_ty(def_id);
219
220 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
238pub(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 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#[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 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 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 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 match ocx.eq(&misc_cause, param_env, opaque_ty, hidden_ty) {
353 Ok(()) => {}
354 Err(ty_err) => {
355 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 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 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 let _ = infcx.take_opaque_types();
398 Ok(())
399 } else {
400 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 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 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 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 ty.ty = strip_vars(ty.ty);
525 let hidden_ty = tcx.type_of(key.def_id).instantiate(tcx, key.args);
527 let hidden_ty = strip_vars(hidden_ty);
528
529 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
539fn 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 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 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(¶m.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 shadowed_captures.contains(¶m.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 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 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 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 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 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 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 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 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 } 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 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 (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 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 tcx.ensure_ok().codegen_fn_attrs(def_id);
993 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 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 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 return res;
1060 }
1061
1062 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 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 Some(parent_item) if traits::impl_item_is_final(tcx, &parent_item) => {
1103 Some(Err(parent_impl.def_id()))
1104 }
1105
1106 Some(_) => Some(Ok(())),
1108
1109 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 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 trait_ref.references_error() {
1145 return;
1146 }
1147
1148 let impl_item_refs = tcx.associated_item_def_ids(impl_id);
1149
1150 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 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 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 && !(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 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 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 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 match element_ty.kind() {
1378 ty::Param(_) => (), ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::RawPtr(_, _) => (), _ => {
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 return;
1508 }
1509
1510 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 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 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 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); 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
1663fn detect_discriminant_duplicate<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>) {
1665 let report = |dis: Discr<'tcx>, idx, err: &mut Diag<'_>| {
1668 let var = adt.variant(idx); let (span, display_discr) = match var.discr {
1670 ty::VariantDiscr::Explicit(discr_def_id) => {
1671 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 (tcx.def_span(discr_def_id), format!("`{dis}`"))
1682 }
1683 }
1684 ty::VariantDiscr::Relative(0) => (tcx.def_span(var.def_id), format!("`{dis}`")),
1686 ty::VariantDiscr::Relative(distance_to_explicit) => {
1687 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 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 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 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 return;
1782 }
1783
1784 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 .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 let has_explicit_bounds = bounded_params.is_empty()
1830 || (*bounded_params).get(¶m.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
1847fn 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 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 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 TypingMode::borrowck(tcx, def_id)
1993 } else {
1994 TypingMode::analysis_in_body(tcx, def_id)
1995 };
1996
1997 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 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 let _ = infcx.take_opaque_types();
2026 }
2027
2028 Ok(())
2029}