Properly check the defining scope of existential types
Fixes #52632 Existential types (soon to be 'impl trait' aliases) can either be delcared at a top-level crate/module scope, or within another item such as an fn. Previously, we were handling the second case incorrectly when recursively searching for defining usages - we would check children of the item, but not the item itself. This lead to us missing closures that consituted a defining use of the existential type, as their opaque type instantiations are stored in the TypeckTables of their parent function. This commit ensures that we explicitly visit the defining item itself, not just its children.
This commit is contained in:
parent
023525dbda
commit
18bf9dd4b7
4 changed files with 58 additions and 9 deletions
|
@ -1189,11 +1189,7 @@ pub fn may_define_existential_type(
|
|||
opaque_hir_id: hir::HirId,
|
||||
) -> bool {
|
||||
let mut hir_id = tcx.hir().as_local_hir_id(def_id).unwrap();
|
||||
trace!(
|
||||
"may_define_existential_type(def={:?}, opaque_node={:?})",
|
||||
tcx.hir().get(hir_id),
|
||||
tcx.hir().get(opaque_hir_id)
|
||||
);
|
||||
|
||||
|
||||
// Named existential types can be defined by any siblings or children of siblings.
|
||||
let scope = tcx.hir().get_defining_scope(opaque_hir_id).expect("could not get defining scope");
|
||||
|
@ -1202,5 +1198,12 @@ pub fn may_define_existential_type(
|
|||
hir_id = tcx.hir().get_parent_item(hir_id);
|
||||
}
|
||||
// Syntactically, we are allowed to define the concrete type if:
|
||||
hir_id == scope
|
||||
let res = hir_id == scope;
|
||||
trace!(
|
||||
"may_define_existential_type(def={:?}, opaque_node={:?}) = {}",
|
||||
tcx.hir().get(hir_id),
|
||||
tcx.hir().get(opaque_hir_id),
|
||||
res
|
||||
);
|
||||
res
|
||||
}
|
||||
|
|
|
@ -1664,6 +1664,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
|
|||
intravisit::NestedVisitorMap::All(&self.tcx.hir())
|
||||
}
|
||||
fn visit_item(&mut self, it: &'tcx Item) {
|
||||
debug!("find_existential_constraints: visiting {:?}", it);
|
||||
let def_id = self.tcx.hir().local_def_id(it.hir_id);
|
||||
// The existential type itself or its children are not within its reveal scope.
|
||||
if def_id != self.def_id {
|
||||
|
@ -1672,6 +1673,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
|
|||
}
|
||||
}
|
||||
fn visit_impl_item(&mut self, it: &'tcx ImplItem) {
|
||||
debug!("find_existential_constraints: visiting {:?}", it);
|
||||
let def_id = self.tcx.hir().local_def_id(it.hir_id);
|
||||
// The existential type itself or its children are not within its reveal scope.
|
||||
if def_id != self.def_id {
|
||||
|
@ -1680,6 +1682,7 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
|
|||
}
|
||||
}
|
||||
fn visit_trait_item(&mut self, it: &'tcx TraitItem) {
|
||||
debug!("find_existential_constraints: visiting {:?}", it);
|
||||
let def_id = self.tcx.hir().local_def_id(it.hir_id);
|
||||
self.check(def_id);
|
||||
intravisit::walk_trait_item(self, it);
|
||||
|
@ -1703,9 +1706,21 @@ fn find_existential_constraints(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
|
|||
} else {
|
||||
debug!("find_existential_constraints: scope={:?}", tcx.hir().get(scope));
|
||||
match tcx.hir().get(scope) {
|
||||
Node::Item(ref it) => intravisit::walk_item(&mut locator, it),
|
||||
Node::ImplItem(ref it) => intravisit::walk_impl_item(&mut locator, it),
|
||||
Node::TraitItem(ref it) => intravisit::walk_trait_item(&mut locator, it),
|
||||
// We explicitly call 'visit_*' methods, instead of using intravisit::walk_* methods
|
||||
// This allows our visitor to process the defining item itself, causing
|
||||
// it to pick up any 'sibling' defining uses.
|
||||
//
|
||||
// For example, this code:
|
||||
// fn foo() {
|
||||
// existential type Blah: Debug;
|
||||
// let my_closure = || -> Blah { true };
|
||||
// }
|
||||
//
|
||||
// requires us to explicitly process 'foo()' in order
|
||||
// to notice the defining usage of 'Blah'
|
||||
Node::Item(ref it) => locator.visit_item(it),
|
||||
Node::ImplItem(ref it) => locator.visit_impl_item(it),
|
||||
Node::TraitItem(ref it) => locator.visit_trait_item(it),
|
||||
other => bug!(
|
||||
"{:?} is not a valid scope for an existential type item",
|
||||
other
|
||||
|
|
11
src/test/ui/existential-type/issue-52843.rs
Normal file
11
src/test/ui/existential-type/issue-52843.rs
Normal file
|
@ -0,0 +1,11 @@
|
|||
#![feature(existential_type)]
|
||||
|
||||
use std::fmt::Debug;
|
||||
|
||||
fn main() {
|
||||
existential type Existential: Debug;
|
||||
fn _unused() -> Existential { String::new() }
|
||||
//~^ ERROR: concrete type differs from previous defining existential type use
|
||||
let null = || -> Existential { 0 };
|
||||
println!("{:?}", null());
|
||||
}
|
20
src/test/ui/existential-type/issue-52843.stderr
Normal file
20
src/test/ui/existential-type/issue-52843.stderr
Normal file
|
@ -0,0 +1,20 @@
|
|||
error: concrete type differs from previous defining existential type use
|
||||
--> $DIR/issue-52843.rs:7:5
|
||||
|
|
||||
LL | fn _unused() -> Existential { String::new() }
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, got `std::string::String`
|
||||
|
|
||||
note: previous use here
|
||||
--> $DIR/issue-52843.rs:5:1
|
||||
|
|
||||
LL | / fn main() {
|
||||
LL | | existential type Existential: Debug;
|
||||
LL | | fn _unused() -> Existential { String::new() }
|
||||
LL | |
|
||||
LL | | let null = || -> Existential { 0 };
|
||||
LL | | println!("{:?}", null());
|
||||
LL | | }
|
||||
| |_^
|
||||
|
||||
error: aborting due to previous error
|
||||
|
Loading…
Reference in a new issue