languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-10-01 14:25:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #118962 - compiler-errors:bugs, r=TaKO8Ki

Browse source 
Annotate some bugs

Gives a semi-helpful message to some `bug!()`/`unreachable!()`/`panic!()`. This also works around some other bugs/panics/etc that weren't needed, and also makes some of them into `span_bug!`s so they also have a useful span.

Note to reviewer: best to disable whitespace when comparing for some cases where indentation changed.

cc #118955
This commit is contained in:
Matthias Krüger 2023-12-15 15:53:51 +01:00 committed by GitHub
parent 4d1bd0db7f 1cc0d7d56c
commit 2f8867e03c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
41 changed files with 319 additions and 223 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_ast_lowering/src/asm.rs
View file

@ -336,7 +336,7 @@ pub(crate) fn lower_inline_asm(
hir::InlineAsmOperand::Const { .. } hir::InlineAsmOperand::Const { .. }
| hir::InlineAsmOperand::SymFn { .. } | hir::InlineAsmOperand::SymFn { .. }
| hir::InlineAsmOperand::SymStatic { .. } => { | hir::InlineAsmOperand::SymStatic { .. } => {
unreachable!() unreachable!("{op:?} is not a register operand");
} }
}; };
@ -380,7 +380,7 @@ pub(crate) fn lower_inline_asm(
{ {
reg_sym.as_str() reg_sym.as_str()
} else { } else {
unreachable!(); unreachable!("{op:?} is not a register operand");
} }
}; };

9
compiler/rustc_ast_lowering/src/item.rs
View file

@ -421,8 +421,13 @@ fn lower_item_kind(
} }
ItemKind::MacroDef(MacroDef { body, macro_rules }) => { ItemKind::MacroDef(MacroDef { body, macro_rules }) => {
let body = P(self.lower_delim_args(body)); let body = P(self.lower_delim_args(body));
let DefKind::Macro(macro_kind) = self.tcx.def_kind(self.local_def_id(id)) else { let def_id = self.local_def_id(id);
unreachable!() let def_kind = self.tcx.def_kind(def_id);
let DefKind::Macro(macro_kind) = def_kind else {
unreachable!(
"expected DefKind::Macro for macro item, found {}",
def_kind.descr(def_id.to_def_id())
);
}; };
let macro_def = self.arena.alloc(ast::MacroDef { body, macro_rules: *macro_rules }); let macro_def = self.arena.alloc(ast::MacroDef { body, macro_rules: *macro_rules });
hir::ItemKind::Macro(macro_def, macro_kind) hir::ItemKind::Macro(macro_def, macro_kind)

2
compiler/rustc_hir/src/hir.rs
View file

@ -2815,7 +2815,7 @@ pub fn trait_def_id(&self) -> Option<DefId> {
match self.path.res { match self.path.res {
Res::Def(DefKind::Trait | DefKind::TraitAlias, did) => Some(did), Res::Def(DefKind::Trait | DefKind::TraitAlias, did) => Some(did),
Res::Err => None, Res::Err => None,
_ => unreachable!(), res => panic!("{res:?} did not resolve to a trait or trait alias"),
} }
} }
} }

22
compiler/rustc_hir_analysis/src/astconv/mod.rs
View file

@ -477,7 +477,10 @@ fn provided_kind(
ty::Const::new_misc_error(tcx, ty).into() ty::Const::new_misc_error(tcx, ty).into()
} }
} }
_ => unreachable!(), (kind, arg) => span_bug!(
self.span,
"mismatched path argument for kind {kind:?}: found arg {arg:?}"
),
} }
} }
@ -1946,7 +1949,7 @@ pub fn prohibit_generics<'a>(
"s", "s",
), ),
[only] => (only.to_string(), ""), [only] => (only.to_string(), ""),
[] => unreachable!(), [] => unreachable!("expected at least one generic to prohibit"),
}; };
let last_span = *arg_spans.last().unwrap(); let last_span = *arg_spans.last().unwrap();
let span: MultiSpan = arg_spans.into(); let span: MultiSpan = arg_spans.into();
@ -2555,8 +2558,19 @@ fn impl_trait_ty_to_ty(
if let Some(i) = (param.index as usize).checked_sub(generics.count() - lifetimes.len()) if let Some(i) = (param.index as usize).checked_sub(generics.count() - lifetimes.len())
{ {
// Resolve our own lifetime parameters. // Resolve our own lifetime parameters.
let GenericParamDefKind::Lifetime { .. } = param.kind else { bug!() }; let GenericParamDefKind::Lifetime { .. } = param.kind else {
let hir::GenericArg::Lifetime(lifetime) = &lifetimes[i] else { bug!() }; span_bug!(
tcx.def_span(param.def_id),
"only expected lifetime for opaque's own generics, got {:?}",
param.kind
);
};
let hir::GenericArg::Lifetime(lifetime) = &lifetimes[i] else {
bug!(
"expected lifetime argument for param {param:?}, found {:?}",
&lifetimes[i]
)
};
self.ast_region_to_region(lifetime, None).into() self.ast_region_to_region(lifetime, None).into()
} else { } else {
tcx.mk_param_from_def(param) tcx.mk_param_from_def(param)

2
compiler/rustc_hir_analysis/src/astconv/object_safety.rs
View file

@ -73,7 +73,7 @@ pub(super) fn conv_object_ty_poly_trait_ref(
| ty::ClauseKind::ConstArgHasType(..) | ty::ClauseKind::ConstArgHasType(..)
| ty::ClauseKind::WellFormed(_) | ty::ClauseKind::WellFormed(_)
| ty::ClauseKind::ConstEvaluatable(_) => { | ty::ClauseKind::ConstEvaluatable(_) => {
bug!() span_bug!(span, "did not expect {pred} clause in object bounds");
} }
} }
} }

165
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View file

@ -1086,8 +1086,14 @@ fn try_fold_region(
_ => return Ok(region), _ => return Ok(region),
} }
let e = if let Some(region) = self.map.get(&region) { let e = if let Some(id_region) = self.map.get(&region) {
if let ty::ReEarlyParam(e) = region.kind() { e } else { bug!() } if let ty::ReEarlyParam(e) = id_region.kind() {
e
} else {
bug!(
"expected to map region {region} to early-bound identity region, but got {id_region}"
);
}
} else { } else {
let guar = match region.kind() { let guar = match region.kind() {
ty::ReEarlyParam(ty::EarlyParamRegion { def_id, .. }) ty::ReEarlyParam(ty::EarlyParamRegion { def_id, .. })
@ -1710,92 +1716,87 @@ fn compare_synthetic_generics<'tcx>(
trait_m.name trait_m.name
); );
err.span_label(trait_span, "declaration in trait here"); err.span_label(trait_span, "declaration in trait here");
match (impl_synthetic, trait_synthetic) { if impl_synthetic {
// The case where the impl method uses `impl Trait` but the trait method uses // The case where the impl method uses `impl Trait` but the trait method uses
// explicit generics // explicit generics
(true, false) => { err.span_label(impl_span, "expected generic parameter, found `impl Trait`");
err.span_label(impl_span, "expected generic parameter, found `impl Trait`"); let _: Option<_> = try {
let _: Option<_> = try { // try taking the name from the trait impl
// try taking the name from the trait impl // FIXME: this is obviously suboptimal since the name can already be used
// FIXME: this is obviously suboptimal since the name can already be used // as another generic argument
// as another generic argument let new_name = tcx.opt_item_name(trait_def_id)?;
let new_name = tcx.opt_item_name(trait_def_id)?; let trait_m = trait_m.def_id.as_local()?;
let trait_m = trait_m.def_id.as_local()?; let trait_m = tcx.hir().expect_trait_item(trait_m);
let trait_m = tcx.hir().expect_trait_item(trait_m);
let impl_m = impl_m.def_id.as_local()?; let impl_m = impl_m.def_id.as_local()?;
let impl_m = tcx.hir().expect_impl_item(impl_m); let impl_m = tcx.hir().expect_impl_item(impl_m);
// in case there are no generics, take the spot between the function name // in case there are no generics, take the spot between the function name
// and the opening paren of the argument list // and the opening paren of the argument list
let new_generics_span = tcx.def_ident_span(impl_def_id)?.shrink_to_hi(); let new_generics_span = tcx.def_ident_span(impl_def_id)?.shrink_to_hi();
// in case there are generics, just replace them // in case there are generics, just replace them
let generics_span = let generics_span = impl_m.generics.span.substitute_dummy(new_generics_span);
impl_m.generics.span.substitute_dummy(new_generics_span); // replace with the generics from the trait
// replace with the generics from the trait let new_generics =
let new_generics = tcx.sess.source_map().span_to_snippet(trait_m.generics.span).ok()?;
tcx.sess.source_map().span_to_snippet(trait_m.generics.span).ok()?;
err.multipart_suggestion( err.multipart_suggestion(
"try changing the `impl Trait` argument to a generic parameter", "try changing the `impl Trait` argument to a generic parameter",
vec![ vec![
// replace `impl Trait` with `T` // replace `impl Trait` with `T`
(impl_span, new_name.to_string()), (impl_span, new_name.to_string()),
// replace impl method generics with trait method generics // replace impl method generics with trait method generics
// This isn't quite right, as users might have changed the names // This isn't quite right, as users might have changed the names
// of the generics, but it works for the common case // of the generics, but it works for the common case
(generics_span, new_generics), (generics_span, new_generics),
], ],
Applicability::MaybeIncorrect, Applicability::MaybeIncorrect,
); );
}; };
} } else {
// The case where the trait method uses `impl Trait`, but the impl method uses // The case where the trait method uses `impl Trait`, but the impl method uses
// explicit generics. // explicit generics.
(false, true) => { err.span_label(impl_span, "expected `impl Trait`, found generic parameter");
err.span_label(impl_span, "expected `impl Trait`, found generic parameter"); let _: Option<_> = try {
let _: Option<_> = try { let impl_m = impl_m.def_id.as_local()?;
let impl_m = impl_m.def_id.as_local()?; let impl_m = tcx.hir().expect_impl_item(impl_m);
let impl_m = tcx.hir().expect_impl_item(impl_m); let (sig, _) = impl_m.expect_fn();
let (sig, _) = impl_m.expect_fn(); let input_tys = sig.decl.inputs;
let input_tys = sig.decl.inputs;
struct Visitor(Option<Span>, hir::def_id::LocalDefId); struct Visitor(Option<Span>, hir::def_id::LocalDefId);
impl<'v> intravisit::Visitor<'v> for Visitor { impl<'v> intravisit::Visitor<'v> for Visitor {
fn visit_ty(&mut self, ty: &'v hir::Ty<'v>) { fn visit_ty(&mut self, ty: &'v hir::Ty<'v>) {
intravisit::walk_ty(self, ty); intravisit::walk_ty(self, ty);
if let hir::TyKind::Path(hir::QPath::Resolved(None, path)) = ty.kind if let hir::TyKind::Path(hir::QPath::Resolved(None, path)) = ty.kind
&& let Res::Def(DefKind::TyParam, def_id) = path.res && let Res::Def(DefKind::TyParam, def_id) = path.res
&& def_id == self.1.to_def_id() && def_id == self.1.to_def_id()
{ {
self.0 = Some(ty.span); self.0 = Some(ty.span);
}
} }
} }
}
let mut visitor = Visitor(None, impl_def_id); let mut visitor = Visitor(None, impl_def_id);
for ty in input_tys { for ty in input_tys {
intravisit::Visitor::visit_ty(&mut visitor, ty); intravisit::Visitor::visit_ty(&mut visitor, ty);
} }
let span = visitor.0?; let span = visitor.0?;
let bounds = impl_m.generics.bounds_for_param(impl_def_id).next()?.bounds; let bounds = impl_m.generics.bounds_for_param(impl_def_id).next()?.bounds;
let bounds = bounds.first()?.span().to(bounds.last()?.span()); let bounds = bounds.first()?.span().to(bounds.last()?.span());
let bounds = tcx.sess.source_map().span_to_snippet(bounds).ok()?; let bounds = tcx.sess.source_map().span_to_snippet(bounds).ok()?;
err.multipart_suggestion( err.multipart_suggestion(
"try removing the generic parameter and using `impl Trait` instead", "try removing the generic parameter and using `impl Trait` instead",
vec![ vec![
// delete generic parameters // delete generic parameters
(impl_m.generics.span, String::new()), (impl_m.generics.span, String::new()),
// replace param usage with `impl Trait` // replace param usage with `impl Trait`
(span, format!("impl {bounds}")), (span, format!("impl {bounds}")),
], ],
Applicability::MaybeIncorrect, Applicability::MaybeIncorrect,
); );
}; };
}
_ => unreachable!(),
} }
error_found = Some(err.emit_unless(delay)); error_found = Some(err.emit_unless(delay));
} }
@ -1859,7 +1860,9 @@ fn compare_generic_param_kinds<'tcx>(
// this is exhaustive so that anyone adding new generic param kinds knows // this is exhaustive so that anyone adding new generic param kinds knows
// to make sure this error is reported for them. // to make sure this error is reported for them.
(Const { .. }, Const { .. }) | (Type { .. }, Type { .. }) => false, (Const { .. }, Const { .. }) | (Type { .. }, Type { .. }) => false,
(Lifetime { .. }, _) | (_, Lifetime { .. }) => unreachable!(), (Lifetime { .. }, _) | (_, Lifetime { .. }) => {
bug!("lifetime params are expected to be filtered by `ty_const_params_of`")
}
} { } {
let param_impl_span = tcx.def_span(param_impl.def_id); let param_impl_span = tcx.def_span(param_impl.def_id);
let param_trait_span = tcx.def_span(param_trait.def_id); let param_trait_span = tcx.def_span(param_trait.def_id);
@ -1883,7 +1886,10 @@ fn compare_generic_param_kinds<'tcx>(
) )
} }
Type { .. } => format!("{prefix} type parameter"), Type { .. } => format!("{prefix} type parameter"),
Lifetime { .. } => unreachable!(), Lifetime { .. } => span_bug!(
tcx.def_span(param.def_id),
"lifetime params are expected to be filtered by `ty_const_params_of`"
),
}; };
let trait_header_span = tcx.def_ident_span(tcx.parent(trait_item.def_id)).unwrap(); let trait_header_span = tcx.def_ident_span(tcx.parent(trait_item.def_id)).unwrap();
@ -2187,7 +2193,10 @@ pub(super) fn check_type_bounds<'tcx>(
.. ..
}) => ty.span, }) => ty.span,
hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Type(ty), .. }) => ty.span, hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Type(ty), .. }) => ty.span,
_ => bug!(), item => span_bug!(
tcx.def_span(impl_ty_def_id),
"cannot call `check_type_bounds` on item: {item:?}",
),
} }
}; };
let assumed_wf_types = ocx.assumed_wf_types_and_report_errors(param_env, impl_ty_def_id)?; let assumed_wf_types = ocx.assumed_wf_types_and_report_errors(param_env, impl_ty_def_id)?;

7
compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
View file

@ -262,7 +262,10 @@ fn report_mismatched_rpitit_signature<'tcx>(
if tcx.asyncness(impl_m_def_id).is_async() && tcx.asyncness(trait_m_def_id).is_async() { if tcx.asyncness(impl_m_def_id).is_async() && tcx.asyncness(trait_m_def_id).is_async() {
let ty::Alias(ty::Projection, future_ty) = return_ty.kind() else { let ty::Alias(ty::Projection, future_ty) = return_ty.kind() else {
bug!(); span_bug!(
tcx.def_span(trait_m_def_id),
"expected return type of async fn in trait to be a AFIT projection"
);
}; };
let Some(future_output_ty) = tcx let Some(future_output_ty) = tcx
.explicit_item_bounds(future_ty.def_id) .explicit_item_bounds(future_ty.def_id)
@ -272,7 +275,7 @@ fn report_mismatched_rpitit_signature<'tcx>(
_ => None, _ => None,
}) })
else { else {
bug!() span_bug!(tcx.def_span(trait_m_def_id), "expected `Future` projection bound in AFIT");
}; };
return_ty = future_output_ty; return_ty = future_output_ty;
} }

17
compiler/rustc_hir_analysis/src/check/intrinsicck.rs
View file

@ -49,7 +49,7 @@ fn get_asm_ty(&self, ty: Ty<'tcx>) -> Option<InlineAsmType> {
16 => InlineAsmType::I16, 16 => InlineAsmType::I16,
32 => InlineAsmType::I32, 32 => InlineAsmType::I32,
64 => InlineAsmType::I64, 64 => InlineAsmType::I64,
_ => unreachable!(), width => bug!("unsupported pointer width: {width}"),
}; };
match *ty.kind() { match *ty.kind() {
@ -101,7 +101,7 @@ fn get_asm_ty(&self, ty: Ty<'tcx>) -> Option<InlineAsmType> {
16 => InlineAsmType::VecI16(size), 16 => InlineAsmType::VecI16(size),
32 => InlineAsmType::VecI32(size), 32 => InlineAsmType::VecI32(size),
64 => InlineAsmType::VecI64(size), 64 => InlineAsmType::VecI64(size),
_ => unreachable!(), width => bug!("unsupported pointer width: {width}"),
}) })
} }
ty::Float(FloatTy::F32) => Some(InlineAsmType::VecF32(size)), ty::Float(FloatTy::F32) => Some(InlineAsmType::VecF32(size)),
@ -109,7 +109,7 @@ fn get_asm_ty(&self, ty: Ty<'tcx>) -> Option<InlineAsmType> {
_ => None, _ => None,
} }
} }
ty::Infer(_) => unreachable!(), ty::Infer(_) => bug!("unexpected infer ty in asm operand"),
_ => None, _ => None,
} }
} }
@ -136,8 +136,15 @@ fn check_asm_operand_type(
ty::Adt(adt, args) if Some(adt.did()) == self.tcx.lang_items().maybe_uninit() => { ty::Adt(adt, args) if Some(adt.did()) == self.tcx.lang_items().maybe_uninit() => {
let fields = &adt.non_enum_variant().fields; let fields = &adt.non_enum_variant().fields;
let ty = fields[FieldIdx::from_u32(1)].ty(self.tcx, args); let ty = fields[FieldIdx::from_u32(1)].ty(self.tcx, args);
let ty::Adt(ty, args) = ty.kind() else { unreachable!() }; // FIXME: Are we just trying to map to the `T` in `MaybeUninit<T>`?
assert!(ty.is_manually_drop()); // If so, just get it from the args.
let ty::Adt(ty, args) = ty.kind() else {
unreachable!("expected first field of `MaybeUninit` to be an ADT")
};
assert!(
ty.is_manually_drop(),
"expected first field of `MaybeUnit` to be `ManuallyDrop`"
);
let fields = &ty.non_enum_variant().fields; let fields = &ty.non_enum_variant().fields;
let ty = fields[FieldIdx::from_u32(0)].ty(self.tcx, args); let ty = fields[FieldIdx::from_u32(0)].ty(self.tcx, args);
self.get_asm_ty(ty) self.get_asm_ty(ty)

50
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View file

@ -204,11 +204,14 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
res = Err(err.emit()); res = Err(err.emit());
} }
// We match on both `ty::ImplPolarity` and `ast::ImplPolarity` just to get the `!` span. // We match on both `ty::ImplPolarity` and `ast::ImplPolarity` just to get the `!` span.
match (tcx.impl_polarity(def_id), impl_.polarity) { match tcx.impl_polarity(def_id) {
(ty::ImplPolarity::Positive, _) => { ty::ImplPolarity::Positive => {
res = res.and(check_impl(tcx, item, impl_.self_ty, &impl_.of_trait)); res = res.and(check_impl(tcx, item, impl_.self_ty, &impl_.of_trait));
} }
(ty::ImplPolarity::Negative, ast::ImplPolarity::Negative(span)) => { ty::ImplPolarity::Negative => {
let ast::ImplPolarity::Negative(span) = impl_.polarity else {
bug!("impl_polarity query disagrees with impl's polarity in AST");
};
// FIXME(#27579): what amount of WF checking do we need for neg impls? // FIXME(#27579): what amount of WF checking do we need for neg impls?
if let hir::Defaultness::Default { .. } = impl_.defaultness { if let hir::Defaultness::Default { .. } = impl_.defaultness {
let mut spans = vec![span]; let mut spans = vec![span];
@ -222,10 +225,9 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
.emit()); .emit());
} }
} }
(ty::ImplPolarity::Reservation, _) => { ty::ImplPolarity::Reservation => {
// FIXME: what amount of WF checking do we need for reservation impls? // FIXME: what amount of WF checking do we need for reservation impls?
} }
_ => unreachable!(),
} }
res res
} }
@ -992,15 +994,6 @@ fn check_associated_item(
}) })
} }
fn item_adt_kind(kind: &ItemKind<'_>) -> Option<AdtKind> {
match kind {
ItemKind::Struct(..) => Some(AdtKind::Struct),
ItemKind::Union(..) => Some(AdtKind::Union),
ItemKind::Enum(..) => Some(AdtKind::Enum),
_ => None,
}
}
/// In a type definition, we check that to ensure that the types of the fields are well-formed. /// In a type definition, we check that to ensure that the types of the fields are well-formed.
fn check_type_defn<'tcx>( fn check_type_defn<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
@ -1068,9 +1061,14 @@ fn check_type_defn<'tcx>(
hir_ty.span, hir_ty.span,
wfcx.body_def_id, wfcx.body_def_id,
traits::FieldSized { traits::FieldSized {
adt_kind: match item_adt_kind(&item.kind) { adt_kind: match &item.kind {
Some(i) => i, ItemKind::Struct(..) => AdtKind::Struct,
None => bug!(), ItemKind::Union(..) => AdtKind::Union,
ItemKind::Enum(..) => AdtKind::Enum,
kind => span_bug!(
item.span,
"should be wfchecking an ADT, got {kind:?}"
),
}, },
span: hir_ty.span, span: hir_ty.span,
last, last,
@ -1302,7 +1300,9 @@ fn check_where_clauses<'tcx>(wfcx: &WfCheckingCtxt<'_, 'tcx>, span: Span, def_id
| GenericParamDefKind::Const { has_default, .. } => { | GenericParamDefKind::Const { has_default, .. } => {
has_default && def.index >= generics.parent_count as u32 has_default && def.index >= generics.parent_count as u32
} }
GenericParamDefKind::Lifetime => unreachable!(), GenericParamDefKind::Lifetime => {
span_bug!(tcx.def_span(def.def_id), "lifetime params can have no default")
}
}; };
// Check that concrete defaults are well-formed. See test `type-check-defaults.rs`. // Check that concrete defaults are well-formed. See test `type-check-defaults.rs`.
@ -1750,15 +1750,15 @@ fn check_variances_for_type_defn<'tcx>(
} }
} }
ItemKind::TyAlias(..) => { ItemKind::TyAlias(..) => {
if tcx.type_alias_is_lazy(item.owner_id) { assert!(
if tcx.type_of(item.owner_id).skip_binder().references_error() { tcx.type_alias_is_lazy(item.owner_id),
return; "should not be computing variance of non-weak type alias"
} );
} else { if tcx.type_of(item.owner_id).skip_binder().references_error() {
bug!(); return;
} }
} }
_ => bug!(), kind => span_bug!(item.span, "cannot compute the variances of {kind:?}"),
} }
let ty_predicates = tcx.predicates_of(item.owner_id); let ty_predicates = tcx.predicates_of(item.owner_id);

4
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -836,7 +836,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
use rustc_hir::*; use rustc_hir::*;
let Node::Item(item) = tcx.hir_node_by_def_id(def_id) else { let Node::Item(item) = tcx.hir_node_by_def_id(def_id) else {
bug!(); bug!("expected ADT to be an item");
}; };
let repr = tcx.repr_options_of_def(def_id.to_def_id()); let repr = tcx.repr_options_of_def(def_id.to_def_id());
@ -887,7 +887,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
(adt_kind, variants) (adt_kind, variants)
} }
_ => bug!(), _ => bug!("{:?} is not an ADT", item.owner_id.def_id),
}; };
tcx.mk_adt_def(def_id.to_def_id(), kind, variants, repr) tcx.mk_adt_def(def_id.to_def_id(), kind, variants, repr)
} }

8
compiler/rustc_hir_analysis/src/collect/item_bounds.rs
View file

@ -97,8 +97,10 @@ pub(super) fn explicit_item_bounds(
item.span, item.span,
)); ));
} }
// These should have been fed! Some(ty::ImplTraitInTraitData::Impl { .. }) => span_bug!(
Some(ty::ImplTraitInTraitData::Impl { .. }) => unreachable!(), tcx.def_span(def_id),
"item bounds for RPITIT in impl to be fed on def-id creation"
),
None => {} None => {}
} }
@ -128,7 +130,7 @@ pub(super) fn explicit_item_bounds(
let (hir::OpaqueTyOrigin::FnReturn(fn_def_id) let (hir::OpaqueTyOrigin::FnReturn(fn_def_id)
| hir::OpaqueTyOrigin::AsyncFn(fn_def_id)) = *origin | hir::OpaqueTyOrigin::AsyncFn(fn_def_id)) = *origin
else { else {
bug!() span_bug!(*span, "RPITIT cannot be a TAIT, but got origin {origin:?}");
}; };
let args = GenericArgs::identity_for_item(tcx, def_id); let args = GenericArgs::identity_for_item(tcx, def_id);
let item_ty = Ty::new_opaque(tcx, def_id.to_def_id(), args); let item_ty = Ty::new_opaque(tcx, def_id.to_def_id(), args);

7
compiler/rustc_hir_analysis/src/collect/predicates_of.rs
View file

@ -296,7 +296,12 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
hir::GenericBound::Outlives(lt) => { hir::GenericBound::Outlives(lt) => {
(icx.astconv().ast_region_to_region(lt, None), lt.ident.span) (icx.astconv().ast_region_to_region(lt, None), lt.ident.span)
} }
_ => bug!(), bound => {
span_bug!(
bound.span(),
"lifetime param bounds must be outlives, but found {bound:?}"
)
}
}; };
let pred = ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2)) let pred = ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2))
.to_predicate(tcx); .to_predicate(tcx);

14
compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
View file

@ -1300,7 +1300,11 @@ fn resolve_lifetime_ref(
what, what,
}) })
} }
_ => unreachable!(), kind => span_bug!(
use_span,
"did not expect to resolve lifetime to {}",
kind.descr(param_def_id)
),
}; };
def = ResolvedArg::Error(guar); def = ResolvedArg::Error(guar);
} else if let Some(body_id) = outermost_body { } else if let Some(body_id) = outermost_body {
@ -1441,7 +1445,11 @@ fn resolve_type_ref(&mut self, param_def_id: LocalDefId, hir_id: hir::HirId) {
what, what,
}) })
} }
_ => unreachable!(), kind => span_bug!(
use_span,
"did not expect to resolve non-lifetime param to {}",
kind.descr(param_def_id.to_def_id())
),
}; };
self.map.defs.insert(hir_id, ResolvedArg::Error(guar)); self.map.defs.insert(hir_id, ResolvedArg::Error(guar));
} else { } else {
@ -2123,7 +2131,7 @@ pub fn deny_non_region_late_bound(
for (var, arg) in bound_vars { for (var, arg) in bound_vars {
let Node::GenericParam(param) = tcx.hir_node_by_def_id(*var) else { let Node::GenericParam(param) = tcx.hir_node_by_def_id(*var) else {
bug!(); span_bug!(tcx.def_span(*var), "expected bound-var def-id to resolve to param");
}; };
let what = match param.kind { let what = match param.kind {

8
compiler/rustc_hir_analysis/src/collect/type_of.rs
View file

@ -20,7 +20,13 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
use rustc_middle::ty::Ty; use rustc_middle::ty::Ty;
let hir_id = tcx.local_def_id_to_hir_id(def_id); let hir_id = tcx.local_def_id_to_hir_id(def_id);
let Node::AnonConst(_) = tcx.hir_node(hir_id) else { panic!() }; let node = tcx.hir_node(hir_id);
let Node::AnonConst(_) = node else {
span_bug!(
tcx.def_span(def_id),
"expected anon const in `anon_const_type_of`, got {node:?}"
);
};
let parent_node_id = tcx.hir().parent_id(hir_id); let parent_node_id = tcx.hir().parent_id(hir_id);
let parent_node = tcx.hir_node(parent_node_id); let parent_node = tcx.hir_node(parent_node_id);

28
compiler/rustc_hir_pretty/src/lib.rs
View file

@ -2003,18 +2003,14 @@ fn print_closure_params(&mut self, decl: &hir::FnDecl<'_>, body_id: hir::BodyId)
}); });
self.word("|"); self.word("|");
if let hir::FnRetTy::DefaultReturn(..) = decl.output {
return;
}
self.space_if_not_bol();
self.word_space("->");
match decl.output { match decl.output {
hir::FnRetTy::Return(ty) => { hir::FnRetTy::Return(ty) => {
self.space_if_not_bol();
self.word_space("->");
self.print_type(ty); self.print_type(ty);
self.maybe_print_comment(ty.span.lo()); self.maybe_print_comment(ty.span.lo());
} }
hir::FnRetTy::DefaultReturn(..) => unreachable!(), hir::FnRetTy::DefaultReturn(..) => {}
} }
} }
@ -2179,7 +2175,7 @@ fn print_where_clause(&mut self, generics: &hir::Generics<'_>) {
GenericBound::Outlives(lt) => { GenericBound::Outlives(lt) => {
self.print_lifetime(lt); self.print_lifetime(lt);
} }
_ => panic!(), _ => panic!("unexpected bound on lifetime param: {bound:?}"),
} }
if i != 0 { if i != 0 {
@ -2216,16 +2212,14 @@ fn print_mt(&mut self, mt: &hir::MutTy<'_>, print_const: bool) {
} }
fn print_fn_output(&mut self, decl: &hir::FnDecl<'_>) { fn print_fn_output(&mut self, decl: &hir::FnDecl<'_>) {
if let hir::FnRetTy::DefaultReturn(..) = decl.output {
return;
}
self.space_if_not_bol();
self.ibox(INDENT_UNIT);
self.word_space("->");
match decl.output { match decl.output {
hir::FnRetTy::DefaultReturn(..) => unreachable!(), hir::FnRetTy::Return(ty) => {
hir::FnRetTy::Return(ty) => self.print_type(ty), self.space_if_not_bol();
self.ibox(INDENT_UNIT);
self.word_space("->");
self.print_type(ty);
}
hir::FnRetTy::DefaultReturn(..) => return,
} }
self.end(); self.end();

14
compiler/rustc_hir_typeck/src/cast.rs
View file

@ -149,7 +149,7 @@ fn pointer_kind(
} }
} }
#[derive(Copy, Clone)] #[derive(Copy, Clone, Debug)]
pub enum CastError { pub enum CastError {
ErrorGuaranteed(ErrorGuaranteed), ErrorGuaranteed(ErrorGuaranteed),
@ -271,7 +271,7 @@ fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx>, e: CastError) {
match e { match e {
CastError::NeedViaPtr => "a raw pointer", CastError::NeedViaPtr => "a raw pointer",
CastError::NeedViaThinPtr => "a thin pointer", CastError::NeedViaThinPtr => "a thin pointer",
_ => bug!(), e => unreachable!("control flow means we should never encounter a {e:?}"),
} }
)); ));
} }
@ -288,13 +288,7 @@ fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx>, e: CastError) {
self.cast_ty, self.cast_ty,
fcx, fcx,
) )
.help(format!( .help("cast through an integer first")
"cast through {} first",
match e {
CastError::NeedViaInt => "an integer",
_ => bug!(),
}
))
.emit(); .emit();
} }
CastError::IllegalCast => { CastError::IllegalCast => {
@ -534,7 +528,7 @@ fn report_cast_error(&self, fcx: &FnCtxt<'a, 'tcx>, e: CastError) {
let unknown_cast_to = match e { let unknown_cast_to = match e {
CastError::UnknownCastPtrKind => true, CastError::UnknownCastPtrKind => true,
CastError::UnknownExprPtrKind => false, CastError::UnknownExprPtrKind => false,
_ => bug!(), e => unreachable!("control flow means we should never encounter a {e:?}"),
}; };
let (span, sub) = if unknown_cast_to { let (span, sub) = if unknown_cast_to {
(self.cast_span, errors::CastUnknownPointerSub::To(self.cast_span)) (self.cast_span, errors::CastUnknownPointerSub::To(self.cast_span))

6
compiler/rustc_hir_typeck/src/coercion.rs
View file

@ -1182,14 +1182,14 @@ fn try_find_coercion_lub<E>(
Adjust::Pointer(PointerCoercion::ClosureFnPointer(a_sig.unsafety())) Adjust::Pointer(PointerCoercion::ClosureFnPointer(a_sig.unsafety()))
} }
ty::FnDef(..) => Adjust::Pointer(PointerCoercion::ReifyFnPointer), ty::FnDef(..) => Adjust::Pointer(PointerCoercion::ReifyFnPointer),
_ => unreachable!(), _ => span_bug!(cause.span, "should not try to coerce a {prev_ty} to a fn pointer"),
}; };
let next_adjustment = match new_ty.kind() { let next_adjustment = match new_ty.kind() {
ty::Closure(..) => { ty::Closure(..) => {
Adjust::Pointer(PointerCoercion::ClosureFnPointer(b_sig.unsafety())) Adjust::Pointer(PointerCoercion::ClosureFnPointer(b_sig.unsafety()))
} }
ty::FnDef(..) => Adjust::Pointer(PointerCoercion::ReifyFnPointer), ty::FnDef(..) => Adjust::Pointer(PointerCoercion::ReifyFnPointer),
_ => unreachable!(), _ => span_bug!(new.span, "should not try to coerce a {new_ty} to a fn pointer"),
}; };
for expr in exprs.iter().map(|e| e.as_coercion_site()) { for expr in exprs.iter().map(|e| e.as_coercion_site()) {
self.apply_adjustments( self.apply_adjustments(
@ -1918,7 +1918,7 @@ fn as_coercion_site(&self) -> &hir::Expr<'_> {
impl AsCoercionSite for ! { impl AsCoercionSite for ! {
fn as_coercion_site(&self) -> &hir::Expr<'_> { fn as_coercion_site(&self) -> &hir::Expr<'_> {
unreachable!() *self
} }
} }

10
compiler/rustc_hir_typeck/src/demand.rs
View file

@ -331,13 +331,15 @@ fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
ty_op: |ty| { ty_op: |ty| {
if let ty::Infer(infer) = ty.kind() { if let ty::Infer(infer) = ty.kind() {
match infer { match infer {
ty::InferTy::TyVar(_) => self.next_ty_var(TypeVariableOrigin { ty::TyVar(_) => self.next_ty_var(TypeVariableOrigin {
kind: TypeVariableOriginKind::MiscVariable, kind: TypeVariableOriginKind::MiscVariable,
span: DUMMY_SP, span: DUMMY_SP,
}), }),
ty::InferTy::IntVar(_) => self.next_int_var(), ty::IntVar(_) => self.next_int_var(),
ty::InferTy::FloatVar(_) => self.next_float_var(), ty::FloatVar(_) => self.next_float_var(),
_ => bug!(), ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
bug!("unexpected fresh ty outside of the trait solver")
}
} }
} else { } else {
ty ty

2
compiler/rustc_hir_typeck/src/expr.rs
View file

@ -2087,7 +2087,7 @@ fn report_private_fields(
let names = names.iter().map(|name| format!("`{name}`")).collect::<Vec<_>>(); let names = names.iter().map(|name| format!("`{name}`")).collect::<Vec<_>>();
format!("{} and `{last}` ", names.join(", ")) format!("{} and `{last}` ", names.join(", "))
} }
[] => unreachable!(), [] => bug!("expected at least one private field to report"),
}; };
err.note(format!( err.note(format!(
"{}private field{s} {names}that {were} not provided", "{}private field{s} {names}that {were} not provided",

4
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View file

@ -993,7 +993,9 @@ enum SuggestionText {
}) { }) {
match e { match e {
Error::Missing(expected_idx) => missing_idxs.push(expected_idx), Error::Missing(expected_idx) => missing_idxs.push(expected_idx),
_ => unreachable!(), _ => unreachable!(
"control flow ensures that we should always get an `Error::Missing`"
),
} }
} }

3
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View file

@ -2072,8 +2072,7 @@ pub(crate) fn suggest_compatible_variants(
Some(CtorKind::Fn) => ("(".to_owned(), ")"), Some(CtorKind::Fn) => ("(".to_owned(), ")"),
None => (format!(" {{ {field_name}: "), " }"), None => (format!(" {{ {field_name}: "), " }"),
// unit variants don't have fields Some(CtorKind::Const) => unreachable!("unit variants don't have fields"),
Some(CtorKind::Const) => unreachable!(),
}; };
// Suggest constructor as deep into the block tree as possible. // Suggest constructor as deep into the block tree as possible.

4
compiler/rustc_hir_typeck/src/method/confirm.rs
View file

@ -415,7 +415,9 @@ fn provided_kind(
) )
.into() .into()
} }
_ => unreachable!(), (kind, arg) => {
bug!("mismatched method arg kind {kind:?} in turbofish: {arg:?}")
}
} }
} }

6
compiler/rustc_hir_typeck/src/pat.rs
View file

@ -1820,7 +1820,11 @@ fn lint_non_exhaustive_omitted_patterns(
fn joined_uncovered_patterns(witnesses: &[&Ident]) -> String { fn joined_uncovered_patterns(witnesses: &[&Ident]) -> String {
const LIMIT: usize = 3; const LIMIT: usize = 3;
match witnesses { match witnesses {
[] => bug!(), [] => {
unreachable!(
"expected an uncovered pattern, otherwise why are we emitting an error?"
)
}
[witness] => format!("`{witness}`"), [witness] => format!("`{witness}`"),
[head @ .., tail] if head.len() < LIMIT => { [head @ .., tail] if head.len() < LIMIT => {
let head: Vec<_> = head.iter().map(<_>::to_string).collect(); let head: Vec<_> = head.iter().map(<_>::to_string).collect();

22
compiler/rustc_infer/src/infer/combine.rs
View file

@ -103,15 +103,19 @@ pub fn super_combine_tys<R>(
} }
// We don't expect `TyVar` or `Fresh*` vars at this point with lazy norm. // We don't expect `TyVar` or `Fresh*` vars at this point with lazy norm.
( (ty::Alias(..), ty::Infer(ty::TyVar(_))) | (ty::Infer(ty::TyVar(_)), ty::Alias(..))
ty::Alias(..), if self.next_trait_solver() =>
ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)), {
) bug!(
| ( "We do not expect to encounter `TyVar` this late in combine \
ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)), -- they should have been handled earlier"
ty::Alias(..), )
) if self.next_trait_solver() => { }
bug!() (_, ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)))
| (ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)), _)
if self.next_trait_solver() =>
{
bug!("We do not expect to encounter `Fresh` variables in the new solver")
} }
(_, ty::Alias(..)) | (ty::Alias(..), _) if self.next_trait_solver() => { (_, ty::Alias(..)) | (ty::Alias(..), _) if self.next_trait_solver() => {

4
compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
View file

@ -232,7 +232,9 @@ fn ty_to_string<'tcx>(
/// something users are familiar with. Directly printing the `fn_sig` of closures also /// something users are familiar with. Directly printing the `fn_sig` of closures also
/// doesn't work as they actually use the "rust-call" API. /// doesn't work as they actually use the "rust-call" API.
fn closure_as_fn_str<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>) -> String { fn closure_as_fn_str<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>) -> String {
let ty::Closure(_, args) = ty.kind() else { unreachable!() }; let ty::Closure(_, args) = ty.kind() else {
bug!("cannot convert non-closure to fn str in `closure_as_fn_str`")
};
let fn_sig = args.as_closure().sig(); let fn_sig = args.as_closure().sig();
let args = fn_sig let args = fn_sig
.inputs() .inputs()

4
compiler/rustc_infer/src/infer/error_reporting/note.rs
View file

@ -375,7 +375,9 @@ pub(super) fn report_placeholder_failure(
err.span_note(span, "the lifetime requirement is introduced here"); err.span_note(span, "the lifetime requirement is introduced here");
err err
} else { } else {
unreachable!() unreachable!(
"control flow ensures we have a `BindingObligation` or `ExprBindingObligation` here..."
)
} }
} }
infer::Subtype(box trace) => { infer::Subtype(box trace) => {

8
compiler/rustc_infer/src/infer/nll_relate/mod.rs
View file

@ -247,7 +247,9 @@ fn relate_opaques(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<
let (a, b) = match (a.kind(), b.kind()) { let (a, b) = match (a.kind(), b.kind()) {
(&ty::Alias(ty::Opaque, ..), _) => (a, generalize(b, false)?), (&ty::Alias(ty::Opaque, ..), _) => (a, generalize(b, false)?),
(_, &ty::Alias(ty::Opaque, ..)) => (generalize(a, true)?, b), (_, &ty::Alias(ty::Opaque, ..)) => (generalize(a, true)?, b),
_ => unreachable!(), _ => unreachable!(
"expected at least one opaque type in `relate_opaques`, got {a} and {b}."
),
}; };
let cause = ObligationCause::dummy_with_span(self.delegate.span()); let cause = ObligationCause::dummy_with_span(self.delegate.span());
let obligations = self let obligations = self
@ -707,7 +709,9 @@ fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {
), ),
// FIXME(deferred_projection_equality): Implement this when we trigger it. // FIXME(deferred_projection_equality): Implement this when we trigger it.
// Probably just need to do nothing here. // Probably just need to do nothing here.
ty::Variance::Bivariant => unreachable!(), ty::Variance::Bivariant => {
unreachable!("cannot defer an alias-relate goal with Bivariant variance (yet?)")
}
})]); })]);
} }
} }

4
compiler/rustc_infer/src/infer/outlives/components.rs
View file

@ -203,7 +203,9 @@ pub(super) fn compute_alias_components_recursive<'tcx>(
out: &mut SmallVec<[Component<'tcx>; 4]>, out: &mut SmallVec<[Component<'tcx>; 4]>,
visited: &mut SsoHashSet<GenericArg<'tcx>>, visited: &mut SsoHashSet<GenericArg<'tcx>>,
) { ) {
let ty::Alias(kind, alias_ty) = alias_ty.kind() else { bug!() }; let ty::Alias(kind, alias_ty) = alias_ty.kind() else {
unreachable!("can only call `compute_alias_components_recursive` on an alias type")
};
let opt_variances = if *kind == ty::Opaque { tcx.variances_of(alias_ty.def_id) } else { &[] }; let opt_variances = if *kind == ty::Opaque { tcx.variances_of(alias_ty.def_id) } else { &[] };
for (index, child) in alias_ty.args.iter().enumerate() { for (index, child) in alias_ty.args.iter().enumerate() {
if opt_variances.get(index) == Some(&ty::Bivariant) { if opt_variances.get(index) == Some(&ty::Bivariant) {

4
compiler/rustc_middle/src/ty/consts/int.rs
View file

@ -71,7 +71,7 @@ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(4, _) => write!(fmt, "_i32")?, (4, _) => write!(fmt, "_i32")?,
(8, _) => write!(fmt, "_i64")?, (8, _) => write!(fmt, "_i64")?,
(16, _) => write!(fmt, "_i128")?, (16, _) => write!(fmt, "_i128")?,
_ => bug!(), (sz, _) => bug!("unexpected int size i{sz}"),
} }
} }
Ok(()) Ok(())
@ -105,7 +105,7 @@ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
(4, _) => write!(fmt, "_u32")?, (4, _) => write!(fmt, "_u32")?,
(8, _) => write!(fmt, "_u64")?, (8, _) => write!(fmt, "_u64")?,
(16, _) => write!(fmt, "_u128")?, (16, _) => write!(fmt, "_u128")?,
_ => bug!(), (sz, _) => bug!("unexpected unsigned int size u{sz}"),
} }
} }
Ok(()) Ok(())

7
compiler/rustc_middle/src/ty/util.rs
View file

@ -421,13 +421,10 @@ pub fn destructor_constraints(self, def: ty::AdtDef<'tcx>) -> Vec<ty::GenericArg
let impl_args = match *self.type_of(impl_def_id).instantiate_identity().kind() { let impl_args = match *self.type_of(impl_def_id).instantiate_identity().kind() {
ty::Adt(def_, args) if def_ == def => args, ty::Adt(def_, args) if def_ == def => args,
_ => bug!(), _ => span_bug!(self.def_span(impl_def_id), "expected ADT for self type of `Drop` impl"),
}; };
let item_args = match *self.type_of(def.did()).instantiate_identity().kind() { let item_args = ty::GenericArgs::identity_for_item(self, def.did());
ty::Adt(def_, args) if def_ == def => args,
_ => bug!(),
};
let result = iter::zip(item_args, impl_args) let result = iter::zip(item_args, impl_args)
.filter(|&(_, k)| { .filter(|&(_, k)| {

8
compiler/rustc_mir_build/src/build/mod.rs
View file

@ -640,7 +640,9 @@ fn construct_error(tcx: TyCtxt<'_>, def_id: LocalDefId, guar: ErrorGuaranteed) -
} }
DefKind::Closure if coroutine_kind.is_some() => { DefKind::Closure if coroutine_kind.is_some() => {
let coroutine_ty = tcx.type_of(def_id).instantiate_identity(); let coroutine_ty = tcx.type_of(def_id).instantiate_identity();
let ty::Coroutine(_, args, _) = coroutine_ty.kind() else { bug!() }; let ty::Coroutine(_, args, _) = coroutine_ty.kind() else {
bug!("expected type of coroutine-like closure to be a coroutine")
};
let args = args.as_coroutine(); let args = args.as_coroutine();
let yield_ty = args.yield_ty(); let yield_ty = args.yield_ty();
let return_ty = args.return_ty(); let return_ty = args.return_ty();
@ -648,7 +650,9 @@ fn construct_error(tcx: TyCtxt<'_>, def_id: LocalDefId, guar: ErrorGuaranteed) -
} }
DefKind::Closure => { DefKind::Closure => {
let closure_ty = tcx.type_of(def_id).instantiate_identity(); let closure_ty = tcx.type_of(def_id).instantiate_identity();
let ty::Closure(_, args) = closure_ty.kind() else { bug!() }; let ty::Closure(_, args) = closure_ty.kind() else {
bug!("expected type of closure to be a closure")
};
let args = args.as_closure(); let args = args.as_closure();
let sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), args.sig()); let sig = tcx.liberate_late_bound_regions(def_id.to_def_id(), args.sig());
let self_ty = match args.kind() { let self_ty = match args.kind() {

2
compiler/rustc_mir_build/src/thir/cx/expr.rs
View file

@ -782,7 +782,7 @@ fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx>
hir::ExprKind::Tup(fields) => ExprKind::Tuple { fields: self.mirror_exprs(fields) }, hir::ExprKind::Tup(fields) => ExprKind::Tuple { fields: self.mirror_exprs(fields) },
hir::ExprKind::Yield(v, _) => ExprKind::Yield { value: self.mirror_expr(v) }, hir::ExprKind::Yield(v, _) => ExprKind::Yield { value: self.mirror_expr(v) },
hir::ExprKind::Err(_) => unreachable!(), hir::ExprKind::Err(_) => unreachable!("cannot lower a `hir::ExprKind::Err` to THIR"),
}; };
Expr { temp_lifetime, ty: expr_ty, span: expr.span, kind } Expr { temp_lifetime, ty: expr_ty, span: expr.span, kind }

5
compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
View file

@ -492,8 +492,9 @@ fn recur(
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_value(tcx, cv, ty)) } PatKind::Constant { value: mir::Const::Ty(ty::Const::new_value(tcx, cv, ty)) }
} }
ty::FnPtr(..) => { ty::FnPtr(..) => {
// Valtree construction would never succeed for these, so this is unreachable. unreachable!(
unreachable!() "Valtree construction would never succeed for FnPtr, so this is unreachable."
)
} }
_ => { _ => {
let err = InvalidPattern { span, non_sm_ty: ty }; let err = InvalidPattern { span, non_sm_ty: ty };

6
compiler/rustc_trait_selection/src/solve/normalizes_to/mod.rs
View file

@ -203,7 +203,11 @@ fn consider_impl_candidate(
) )
.into(), .into(),
ty::AssocKind::Type => Ty::new_error(tcx, guar).into(), ty::AssocKind::Type => Ty::new_error(tcx, guar).into(),
ty::AssocKind::Fn => unreachable!(), // This makes no sense...
ty::AssocKind::Fn => span_bug!(
tcx.def_span(assoc_def.item.def_id),
"cannot project to an associated function"
),
}; };
ecx.eq(goal.param_env, goal.predicate.term, error_term) ecx.eq(goal.param_env, goal.predicate.term, error_term)
.expect("expected goal term to be fully unconstrained"); .expect("expected goal term to be fully unconstrained");

5
compiler/rustc_trait_selection/src/solve/trait_goals.rs
View file

@ -256,7 +256,10 @@ fn consider_builtin_fn_ptr_trait_candidate(
Err(NoSolution) Err(NoSolution)
} }
} }
ty::ImplPolarity::Reservation => bug!(), // FIXME: Goal polarity should be split from impl polarity
ty::ImplPolarity::Reservation => {
bug!("we never expect a `Reservation` polarity in a trait goal")
}
} }
} }

6
compiler/rustc_trait_selection/src/traits/coherence.rs
View file

@ -487,7 +487,7 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
), ),
) )
else { else {
bug!() bug!("we always expect to be able to plug an infer var with placeholder")
}; };
assert_eq!(obligations, &[]); assert_eq!(obligations, &[]);
ControlFlow::Continue(()) ControlFlow::Continue(())
@ -510,7 +510,7 @@ fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
), ),
) )
else { else {
bug!() bug!("we always expect to be able to plug an infer var with placeholder")
}; };
assert_eq!(obligations, &[]); assert_eq!(obligations, &[]);
ControlFlow::Continue(()) ControlFlow::Continue(())
@ -544,7 +544,7 @@ fn visit_region(&mut self, r: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> {
), ),
) )
else { else {
bug!() bug!("we always expect to be able to plug an infer var with placeholder")
}; };
assert_eq!(obligations, &[]); assert_eq!(obligations, &[]);
} }

7
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View file

@ -250,7 +250,12 @@ fn report_overflow_error<T>(
err.emit(); err.emit();
self.tcx.sess.abort_if_errors(); self.tcx.sess.abort_if_errors();
bug!(); // FIXME: this should be something like `build_overflow_error_fatal`, which returns
// `DiagnosticBuilder<', !>`. Then we don't even need anything after that `emit()`.
unreachable!(
"did not expect compilation to continue after `abort_if_errors`, \
since an error was definitely emitted!"
);
} }
fn build_overflow_error<T>( fn build_overflow_error<T>(

40
compiler/rustc_trait_selection/src/traits/project.rs
View file

@ -191,7 +191,9 @@ fn push_candidate(&mut self, candidate: ProjectionCandidate<'tcx>) -> bool {
match (current, candidate) { match (current, candidate) {
(ParamEnv(..), ParamEnv(..)) => convert_to_ambiguous = (), (ParamEnv(..), ParamEnv(..)) => convert_to_ambiguous = (),
(ParamEnv(..), _) => return false, (ParamEnv(..), _) => return false,
(_, ParamEnv(..)) => unreachable!(), (_, ParamEnv(..)) => bug!(
"should never prefer non-param-env candidates over param-env candidates"
),
(_, _) => convert_to_ambiguous = (), (_, _) => convert_to_ambiguous = (),
} }
} }
@ -2080,10 +2082,11 @@ fn confirm_coroutine_candidate<'cx, 'tcx>(
obligation: &ProjectionTyObligation<'tcx>, obligation: &ProjectionTyObligation<'tcx>,
nested: Vec<PredicateObligation<'tcx>>, nested: Vec<PredicateObligation<'tcx>>,
) -> Progress<'tcx> { ) -> Progress<'tcx> {
let ty::Coroutine(_, args, _) = let self_ty = selcx.infcx.shallow_resolve(obligation.predicate.self_ty());
selcx.infcx.shallow_resolve(obligation.predicate.self_ty()).kind() let ty::Coroutine(_, args, _) = self_ty.kind() else {
else { unreachable!(
unreachable!() "expected coroutine self type for built-in coroutine candidate, found {self_ty}"
)
}; };
let coroutine_sig = args.as_coroutine().sig(); let coroutine_sig = args.as_coroutine().sig();
let Normalized { value: coroutine_sig, obligations } = normalize_with_depth( let Normalized { value: coroutine_sig, obligations } = normalize_with_depth(
@ -2113,7 +2116,10 @@ fn confirm_coroutine_candidate<'cx, 'tcx>(
} else if name == sym::Yield { } else if name == sym::Yield {
yield_ty yield_ty
} else { } else {
bug!() span_bug!(
tcx.def_span(obligation.predicate.def_id),
"unexpected associated type: `Coroutine::{name}`"
);
}; };
let predicate = ty::ProjectionPredicate { let predicate = ty::ProjectionPredicate {
@ -2131,10 +2137,11 @@ fn confirm_future_candidate<'cx, 'tcx>(
obligation: &ProjectionTyObligation<'tcx>, obligation: &ProjectionTyObligation<'tcx>,
nested: Vec<PredicateObligation<'tcx>>, nested: Vec<PredicateObligation<'tcx>>,
) -> Progress<'tcx> { ) -> Progress<'tcx> {
let ty::Coroutine(_, args, _) = let self_ty = selcx.infcx.shallow_resolve(obligation.predicate.self_ty());
selcx.infcx.shallow_resolve(obligation.predicate.self_ty()).kind() let ty::Coroutine(_, args, _) = self_ty.kind() else {
else { unreachable!(
unreachable!() "expected coroutine self type for built-in async future candidate, found {self_ty}"
)
}; };
let coroutine_sig = args.as_coroutine().sig(); let coroutine_sig = args.as_coroutine().sig();
let Normalized { value: coroutine_sig, obligations } = normalize_with_depth( let Normalized { value: coroutine_sig, obligations } = normalize_with_depth(
@ -2174,10 +2181,9 @@ fn confirm_iterator_candidate<'cx, 'tcx>(
obligation: &ProjectionTyObligation<'tcx>, obligation: &ProjectionTyObligation<'tcx>,
nested: Vec<PredicateObligation<'tcx>>, nested: Vec<PredicateObligation<'tcx>>,
) -> Progress<'tcx> { ) -> Progress<'tcx> {
let ty::Coroutine(_, args, _) = let self_ty = selcx.infcx.shallow_resolve(obligation.predicate.self_ty());
selcx.infcx.shallow_resolve(obligation.predicate.self_ty()).kind() let ty::Coroutine(_, args, _) = self_ty.kind() else {
else { unreachable!("expected coroutine self type for built-in gen candidate, found {self_ty}")
unreachable!()
}; };
let gen_sig = args.as_coroutine().sig(); let gen_sig = args.as_coroutine().sig();
let Normalized { value: gen_sig, obligations } = normalize_with_depth( let Normalized { value: gen_sig, obligations } = normalize_with_depth(
@ -2341,9 +2347,9 @@ fn confirm_closure_candidate<'cx, 'tcx>(
obligation: &ProjectionTyObligation<'tcx>, obligation: &ProjectionTyObligation<'tcx>,
nested: Vec<PredicateObligation<'tcx>>, nested: Vec<PredicateObligation<'tcx>>,
) -> Progress<'tcx> { ) -> Progress<'tcx> {
let ty::Closure(_, args) = selcx.infcx.shallow_resolve(obligation.predicate.self_ty()).kind() let self_ty = selcx.infcx.shallow_resolve(obligation.predicate.self_ty());
else { let ty::Closure(_, args) = self_ty.kind() else {
unreachable!() unreachable!("expected closure self type for closure candidate, found {self_ty}")
}; };
let closure_sig = args.as_closure().sig(); let closure_sig = args.as_closure().sig();
let Normalized { value: closure_sig, obligations } = normalize_with_depth( let Normalized { value: closure_sig, obligations } = normalize_with_depth(

2
compiler/rustc_trait_selection/src/traits/query/normalize.rs
View file

@ -285,7 +285,7 @@ fn try_fold_ty(&mut self, ty: Ty<'tcx>) -> Result<Ty<'tcx>, Self::Error> {
ty::Projection => tcx.normalize_projection_ty(c_data), ty::Projection => tcx.normalize_projection_ty(c_data),
ty::Weak => tcx.normalize_weak_ty(c_data), ty::Weak => tcx.normalize_weak_ty(c_data),
ty::Inherent => tcx.normalize_inherent_projection_ty(c_data), ty::Inherent => tcx.normalize_inherent_projection_ty(c_data),
_ => unreachable!(), kind => unreachable!("did not expect {kind:?} due to match arm above"),
}?; }?;
// We don't expect ambiguity. // We don't expect ambiguity.
if !result.value.is_proven() { if !result.value.is_proven() {

4
compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
View file

@ -184,7 +184,9 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
push_outlives_components(tcx, ty_a, &mut components); push_outlives_components(tcx, ty_a, &mut components);
implied_bounds.extend(implied_bounds_from_components(r_b, components)) implied_bounds.extend(implied_bounds_from_components(r_b, components))
} }
ty::GenericArgKind::Const(_) => unreachable!(), ty::GenericArgKind::Const(_) => {
unreachable!("consts do not participate in outlives bounds")
}
} }
} }

8
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View file

@ -942,8 +942,12 @@ fn confirm_trait_upcasting_unsize_candidate(
let a_ty = self.infcx.shallow_resolve(predicate.self_ty()); let a_ty = self.infcx.shallow_resolve(predicate.self_ty());
let b_ty = self.infcx.shallow_resolve(predicate.trait_ref.args.type_at(1)); let b_ty = self.infcx.shallow_resolve(predicate.trait_ref.args.type_at(1));
let ty::Dynamic(a_data, a_region, ty::Dyn) = *a_ty.kind() else { bug!() }; let ty::Dynamic(a_data, a_region, ty::Dyn) = *a_ty.kind() else {
let ty::Dynamic(b_data, b_region, ty::Dyn) = *b_ty.kind() else { bug!() }; bug!("expected `dyn` type in `confirm_trait_upcasting_unsize_candidate`")
};
let ty::Dynamic(b_data, b_region, ty::Dyn) = *b_ty.kind() else {
bug!("expected `dyn` type in `confirm_trait_upcasting_unsize_candidate`")
};
let source_principal = a_data.principal().unwrap().with_self_ty(tcx, a_ty); let source_principal = a_data.principal().unwrap().with_self_ty(tcx, a_ty);
let unnormalized_upcast_principal = let unnormalized_upcast_principal =