let concrete_ty = tcx
.mir_borrowck(owner)
.concrete_opaque_types
- .get(&def_id.to_def_id())
+ .get(&def_id)
.copied()
.map(|concrete| concrete.ty)
.unwrap_or_else(|| {
// the `concrete_opaque_types` table.
tcx.ty_error()
} else {
- table.concrete_opaque_types.get(&def_id.to_def_id()).copied().unwrap_or_else(|| {
+ table.concrete_opaque_types.get(&def_id).copied().unwrap_or_else(|| {
// We failed to resolve the opaque type or it
// resolves to itself. We interpret this as the
// no values of the hidden type ever being constructed,
tcx: TyCtxt<'tcx>,
/// def_id of the opaque type whose defining uses are being checked
- def_id: DefId,
+ def_id: LocalDefId,
/// as we walk the defining uses, we are checking that all of them
/// define the same hidden type. This variable is set to `Some`
impl ConstraintLocator<'_> {
#[instrument(skip(self), level = "debug")]
- fn check(&mut self, def_id: LocalDefId) {
+ fn check(&mut self, item_def_id: LocalDefId) {
// Don't try to check items that cannot possibly constrain the type.
- if !self.tcx.has_typeck_results(def_id) {
+ if !self.tcx.has_typeck_results(item_def_id) {
debug!("no constraint: no typeck results");
return;
}
// // because we again need to reveal `Foo` so we can check whether the
// // constant does not contain interior mutability.
// ```
- let tables = self.tcx.typeck(def_id);
+ let tables = self.tcx.typeck(item_def_id);
if let Some(_) = tables.tainted_by_errors {
self.found = Some(ty::OpaqueHiddenType { span: DUMMY_SP, ty: self.tcx.ty_error() });
return;
}
- if tables.concrete_opaque_types.get(&self.def_id).is_none() {
+ if !tables.concrete_opaque_types.contains_key(&self.def_id) {
debug!("no constraints in typeck results");
return;
}
// Use borrowck to get the type with unerased regions.
- let concrete_opaque_types = &self.tcx.mir_borrowck(def_id).concrete_opaque_types;
+ let concrete_opaque_types = &self.tcx.mir_borrowck(item_def_id).concrete_opaque_types;
debug!(?concrete_opaque_types);
- for &(def_id, concrete_type) in concrete_opaque_types {
- if def_id != self.def_id {
- // Ignore constraints for other opaque types.
- continue;
- }
-
+ if let Some(&concrete_type) = concrete_opaque_types.get(&self.def_id) {
debug!(?concrete_type, "found constraint");
-
if let Some(prev) = self.found {
if concrete_type.ty != prev.ty && !(concrete_type, prev).references_error() {
prev.report_mismatch(&concrete_type, self.tcx);
fn visit_item(&mut self, it: &'tcx Item<'tcx>) {
trace!(?it.def_id);
// The opaque type itself or its children are not within its reveal scope.
- if it.def_id.to_def_id() != self.def_id {
+ if it.def_id != self.def_id {
self.check(it.def_id);
intravisit::walk_item(self, it);
}
fn visit_impl_item(&mut self, it: &'tcx ImplItem<'tcx>) {
trace!(?it.def_id);
// The opaque type itself or its children are not within its reveal scope.
- if it.def_id.to_def_id() != self.def_id {
+ if it.def_id != self.def_id {
self.check(it.def_id);
intravisit::walk_impl_item(self, it);
}
let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
let scope = tcx.hir().get_defining_scope(hir_id);
- let mut locator = ConstraintLocator { def_id: def_id.to_def_id(), tcx, found: None };
+ let mut locator = ConstraintLocator { def_id: def_id, tcx, found: None };
debug!(?scope);