Report all intermediate expansions of trait aliases.

Author: Alexander Regueiro

src/librustc/traits/util.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use smallvec::SmallVec;
+
 use hir::{self};
 use hir::def_id::DefId;
 use syntax_pos::Span;
@@ -282,63 +284,79 @@ pub struct TraitRefExpander<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
 
 #[derive(Debug, Clone)]
 pub struct TraitRefExpansionInfo<'tcx> {
-    pub top_level_trait_ref: ty::PolyTraitRef<'tcx>,
-    pub top_level_span: Span,
-    pub trait_ref: ty::PolyTraitRef<'tcx>,
-    pub span: Span,
+    pub items: SmallVec<[(ty::PolyTraitRef<'tcx>, Span); 4]>,
+}
+
+impl<'tcx> TraitRefExpansionInfo<'tcx> {
+    fn new(trait_ref: ty::PolyTraitRef<'tcx>, span: Span) -> TraitRefExpansionInfo<'tcx> {
+        TraitRefExpansionInfo {
+            items: smallvec![(trait_ref, span)]
+        }
+    }
+
+    fn push(&self, trait_ref: ty::PolyTraitRef<'tcx>, span: Span) -> TraitRefExpansionInfo<'tcx> {
+        let mut items = self.items.clone();
+        items.push((trait_ref, span));
+
+        TraitRefExpansionInfo {
+            items
+        }
+    }
+
+    pub fn trait_ref(&self) -> &ty::PolyTraitRef<'tcx> {
+        &self.top().0
+    }
+
+    pub fn top(&self) -> &(ty::PolyTraitRef<'tcx>, Span) {
+        self.items.last().unwrap()
+    }
+
+    pub fn bottom(&self) -> &(ty::PolyTraitRef<'tcx>, Span) {
+        self.items.first().unwrap()
+    }
 }
 
 pub fn expand_trait_refs<'cx, 'gcx, 'tcx>(
     tcx: TyCtxt<'cx, 'gcx, 'tcx>,
     trait_refs: impl IntoIterator<Item = (ty::PolyTraitRef<'tcx>, Span)>
 ) -> TraitRefExpander<'cx, 'gcx, 'tcx> {
     let mut visited = PredicateSet::new(tcx);
-    let mut items: Vec<_> =
-        trait_refs.into_iter()
-        .map(|(tr, sp)| TraitRefExpansionInfo {
-            top_level_trait_ref: tr.clone(),
-            top_level_span: sp,
-            trait_ref: tr,
-            span: sp,
-        })
+    let mut items: Vec<_> = trait_refs
+        .into_iter()
+        .map(|(tr, sp)| TraitRefExpansionInfo::new(tr, sp))
         .collect();
-    items.retain(|item| visited.insert(&item.trait_ref.to_predicate()));
+    items.retain(|i| visited.insert(&i.trait_ref().to_predicate()));
     TraitRefExpander { stack: items, visited: visited, }
 }
 
 impl<'cx, 'gcx, 'tcx> TraitRefExpander<'cx, 'gcx, 'tcx> {
     // Returns `true` if `item` refers to a trait.
     fn push(&mut self, item: &TraitRefExpansionInfo<'tcx>) -> bool {
         let tcx = self.visited.tcx;
+        let trait_ref = item.trait_ref();
 
-        if !ty::is_trait_alias(tcx, item.trait_ref.def_id()) {
+        if !ty::is_trait_alias(tcx, trait_ref.def_id()) {
             return true;
         }
 
         // Get predicates declared on the trait.
-        let predicates = tcx.super_predicates_of(item.trait_ref.def_id());
+        let predicates = tcx.super_predicates_of(trait_ref.def_id());
 
         let mut items: Vec<_> = predicates.predicates
             .iter()
             .rev()
             .filter_map(|(pred, sp)| {
-                pred.subst_supertrait(tcx, &item.trait_ref)
+                pred.subst_supertrait(tcx, &trait_ref)
                     .to_opt_poly_trait_ref()
-                    .map(|trait_ref|
-                        TraitRefExpansionInfo {
-                            trait_ref,
-                            span: *sp,
-                            ..*item
-                        }
-                    )
+                    .map(|tr| item.push(tr, *sp))
             })
             .collect();
 
         debug!("expand_trait_refs: trait_ref={:?} items={:?}",
-                item.trait_ref, items);
+                trait_ref, items);
 
         // Only keep those items that we haven't already seen.
-        items.retain(|i| self.visited.insert(&i.trait_ref.to_predicate()));
+        items.retain(|i| self.visited.insert(&i.trait_ref().to_predicate()));
 
         self.stack.extend(items);
         false

src/librustc_typeck/astconv.rs

@@ -949,7 +949,8 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
     /// Transform a `PolyTraitRef` into a `PolyExistentialTraitRef` by
     /// removing the dummy `Self` type (`TRAIT_OBJECT_DUMMY_SELF`).
     fn trait_ref_to_existential(&self, trait_ref: ty::TraitRef<'tcx>)
-                                -> ty::ExistentialTraitRef<'tcx> {
+                                -> ty::ExistentialTraitRef<'tcx>
+    {
         assert_eq!(trait_ref.self_ty().sty, TRAIT_OBJECT_DUMMY_SELF);
         ty::ExistentialTraitRef::erase_self_ty(self.tcx(), trait_ref)
     }
@@ -989,14 +990,16 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
 
         let expanded_traits = traits::expand_trait_refs(tcx, bound_trait_refs);
         let (auto_traits, regular_traits): (Vec<_>, Vec<_>) =
-            expanded_traits.partition(|i| tcx.trait_is_auto(i.trait_ref.def_id()));
+            expanded_traits.partition(|i| tcx.trait_is_auto(i.trait_ref().def_id()));
         if regular_traits.len() > 1 {
             let extra_trait = &regular_traits[1];
-            let mut err = struct_span_err!(tcx.sess, extra_trait.top_level_span, E0225,
+            let mut err = struct_span_err!(tcx.sess, extra_trait.bottom().1, E0225,
                 "only auto traits can be used as additional traits in a trait object");
-            err.span_label(extra_trait.span, "non-auto additional trait");
-            if extra_trait.span != extra_trait.top_level_span {
-                err.span_label(extra_trait.top_level_span, "expanded from this alias");
+            err.span_label(extra_trait.top().1, "non-auto additional trait");
+            if extra_trait.items.len() > 2 {
+                for (_, sp) in extra_trait.items[1..(extra_trait.items.len() - 1)].iter().rev() {
+                    err.span_label(*sp, "referenced by this alias");
+                }
             }
             err.emit();
         }
@@ -1123,14 +1126,14 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
         // Dedup auto traits so that e.g. `dyn Trait + Send + Send` is the same as
         // `dyn Trait + Send`. Skip the first auto trait if it is the principal trait.
         let auto_traits_start_index =
-            if auto_traits.first().map_or(false, |i| i.trait_ref == principal) {
+            if auto_traits.first().map_or(false, |i| i.trait_ref() == &principal) {
                 1
             } else {
                 0
             };
         let mut auto_traits: Vec<_> =
             auto_traits[auto_traits_start_index..].into_iter()
-                                                  .map(|i| i.trait_ref.def_id())
+                                                  .map(|i| i.trait_ref().def_id())
                                                   .collect();
         auto_traits.sort();
         auto_traits.dedup();

src/test/ui/error-codes/E0225.rs

@@ -11,8 +11,9 @@
 #![feature(trait_alias)]
 
 trait Foo = std::io::Read + std::io::Write;
+trait Bar = Foo;
 
 fn main() {
     let _: Box<std::io::Read + std::io::Write>;
-    let _: Box<Foo>;
+    let _: Box<Bar>;
 }

src/test/ui/error-codes/E0225.stderr

@@ -1,17 +1,19 @@
 error[E0225]: only auto traits can be used as additional traits in a trait object
-  --> $DIR/E0225.rs:16:32
+  --> $DIR/E0225.rs:17:32
    |
 LL |     let _: Box<std::io::Read + std::io::Write>;
    |                                ^^^^^^^^^^^^^^ non-auto additional trait
 
 error[E0225]: only auto traits can be used as additional traits in a trait object
-  --> $DIR/E0225.rs:17:16
+  --> $DIR/E0225.rs:18:16
    |
 LL | trait Foo = std::io::Read + std::io::Write;
    |                             -------------- non-auto additional trait
+LL | trait Bar = Foo;
+   |             --- referenced by this alias
 ...
-LL |     let _: Box<Foo>;
-   |                ^^^ expanded from this alias
+LL |     let _: Box<Bar>;
+   |                ^^^
 
 error: aborting due to 2 previous errors