squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

save-analysis: Process bounds in impl trait only in argument position

Browse source
This commit is contained in:
Igor Matuszewski 2019-09-15 00:42:18 +02:00
parent 30e39e871f
commit a946b8d6e1
2 changed files with 26 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
src/librustc_save_analysis/dump_visitor.rs
View file

@ -385,8 +385,13 @@ impl<'l, 'tcx> DumpVisitor<'l, 'tcx> {
}
if let ast::FunctionRetTy::Ty(ref ret_ty) = decl.output {
if let ast::TyKind::ImplTrait(..) = ret_ty.node {
// FIXME: Opaque type desugaring prevents us from easily
// processing trait bounds. See `visit_ty` for more details.
} else {
v.visit_ty(&ret_ty);
}
}
v.visit_block(&body);
});
@ -1439,6 +1444,18 @@ impl<'l, 'tcx> Visitor<'l> for DumpVisitor<'l, 'tcx> {
self.visit_ty(element);
self.nest_tables(length.id, |v| v.visit_expr(&length.value));
}
ast::TyKind::ImplTrait(id, ref bounds) => {
// FIXME: As of writing, the opaque type lowering introduces
// another DefPath scope/segment (used to declare the resulting
// opaque type item).
// However, the synthetic scope does *not* have associated
// typeck tables, which means we can't nest it and we fire an
// assertion when resolving the qualified type paths in trait
// bounds...
// This will panic if called on return type `impl Trait`, which
// we guard against in `process_fn`.
self.nest_tables(id, |v| v.process_bounds(bounds));
}
_ => visit::walk_ty(self, t),
}
}

11
src/test/ui/save-analysis/issue-63663.rs
View file

@ -1,15 +1,20 @@
// check-pass
// compile-flags: -Zsave-analysis
// Check that this doesn't ICE when processing associated const in formal
// argument and return type of functions defined inside function/method scope.
pub trait Trait {
type Assoc;
}
pub struct A;
trait Generic<T> {}
impl<T> Generic<T> for () {}
// Don't ICE when resolving type paths in return type `impl Trait`
fn assoc_in_opaque_type_bounds<U: Trait>() -> impl Generic<U::Assoc> {}
// Check that this doesn't ICE when processing associated const in formal
// argument and return type of functions defined inside function/method scope.
pub fn func() {
fn _inner1<U: Trait>(_: U::Assoc) {}
fn _inner2<U: Trait>() -> U::Assoc { unimplemented!() }